﻿#if USE_UNI_LUA
using LuaAPI = UniLua.Lua;
using RealStatePtr = UniLua.ILuaState;
using LuaCSFunction = UniLua.CSharpFunctionDelegate;
#else
using LuaAPI = XLua.LuaDLL.Lua;
using RealStatePtr = System.IntPtr;
using LuaCSFunction = XLuaBase.lua_CSFunction;
#endif

using XLua;
using System.Collections.Generic;


namespace XLua.CSObjectWrap
{
    using Utils = XLua.Utils;
    
    public class YoozooManagersResourceManagerV2FrameworkResourceHasAssetResultWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(Yoozoo.Managers.ResourceManagerV2.Framework.Resource.HasAssetResult), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(Yoozoo.Managers.ResourceManagerV2.Framework.Resource.HasAssetResult), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(Yoozoo.Managers.ResourceManagerV2.Framework.Resource.HasAssetResult), L, null, 7, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NotExist", Yoozoo.Managers.ResourceManagerV2.Framework.Resource.HasAssetResult.NotExist);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NotReady", Yoozoo.Managers.ResourceManagerV2.Framework.Resource.HasAssetResult.NotReady);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AssetOnDisk", Yoozoo.Managers.ResourceManagerV2.Framework.Resource.HasAssetResult.AssetOnDisk);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AssetOnFileSystem", Yoozoo.Managers.ResourceManagerV2.Framework.Resource.HasAssetResult.AssetOnFileSystem);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BinaryOnDisk", Yoozoo.Managers.ResourceManagerV2.Framework.Resource.HasAssetResult.BinaryOnDisk);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BinaryOnFileSystem", Yoozoo.Managers.ResourceManagerV2.Framework.Resource.HasAssetResult.BinaryOnFileSystem);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(Yoozoo.Managers.ResourceManagerV2.Framework.Resource.HasAssetResult), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushYoozooManagersResourceManagerV2FrameworkResourceHasAssetResult(L, (Yoozoo.Managers.ResourceManagerV2.Framework.Resource.HasAssetResult)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "NotExist"))
                {
                    translator.PushYoozooManagersResourceManagerV2FrameworkResourceHasAssetResult(L, Yoozoo.Managers.ResourceManagerV2.Framework.Resource.HasAssetResult.NotExist);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "NotReady"))
                {
                    translator.PushYoozooManagersResourceManagerV2FrameworkResourceHasAssetResult(L, Yoozoo.Managers.ResourceManagerV2.Framework.Resource.HasAssetResult.NotReady);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "AssetOnDisk"))
                {
                    translator.PushYoozooManagersResourceManagerV2FrameworkResourceHasAssetResult(L, Yoozoo.Managers.ResourceManagerV2.Framework.Resource.HasAssetResult.AssetOnDisk);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "AssetOnFileSystem"))
                {
                    translator.PushYoozooManagersResourceManagerV2FrameworkResourceHasAssetResult(L, Yoozoo.Managers.ResourceManagerV2.Framework.Resource.HasAssetResult.AssetOnFileSystem);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "BinaryOnDisk"))
                {
                    translator.PushYoozooManagersResourceManagerV2FrameworkResourceHasAssetResult(L, Yoozoo.Managers.ResourceManagerV2.Framework.Resource.HasAssetResult.BinaryOnDisk);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "BinaryOnFileSystem"))
                {
                    translator.PushYoozooManagersResourceManagerV2FrameworkResourceHasAssetResult(L, Yoozoo.Managers.ResourceManagerV2.Framework.Resource.HasAssetResult.BinaryOnFileSystem);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for Yoozoo.Managers.ResourceManagerV2.Framework.Resource.HasAssetResult!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for Yoozoo.Managers.ResourceManagerV2.Framework.Resource.HasAssetResult! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class BunkerHitPointTypeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(BunkerHitPointType), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(BunkerHitPointType), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(BunkerHitPointType), L, null, 9, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Metal", BunkerHitPointType.Metal);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Wall", BunkerHitPointType.Wall);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PaperBox", BunkerHitPointType.PaperBox);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Wood", BunkerHitPointType.Wood);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MetalBack", BunkerHitPointType.MetalBack);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "WallBack", BunkerHitPointType.WallBack);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PaperBoxBack", BunkerHitPointType.PaperBoxBack);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "WoodBack", BunkerHitPointType.WoodBack);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(BunkerHitPointType), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushBunkerHitPointType(L, (BunkerHitPointType)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Metal"))
                {
                    translator.PushBunkerHitPointType(L, BunkerHitPointType.Metal);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Wall"))
                {
                    translator.PushBunkerHitPointType(L, BunkerHitPointType.Wall);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "PaperBox"))
                {
                    translator.PushBunkerHitPointType(L, BunkerHitPointType.PaperBox);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Wood"))
                {
                    translator.PushBunkerHitPointType(L, BunkerHitPointType.Wood);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "MetalBack"))
                {
                    translator.PushBunkerHitPointType(L, BunkerHitPointType.MetalBack);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "WallBack"))
                {
                    translator.PushBunkerHitPointType(L, BunkerHitPointType.WallBack);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "PaperBoxBack"))
                {
                    translator.PushBunkerHitPointType(L, BunkerHitPointType.PaperBoxBack);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "WoodBack"))
                {
                    translator.PushBunkerHitPointType(L, BunkerHitPointType.WoodBack);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for BunkerHitPointType!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for BunkerHitPointType! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class DGTweeningEaseWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(DG.Tweening.Ease), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(DG.Tweening.Ease), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(DG.Tweening.Ease), L, null, 39, 0, 0);

            Utils.RegisterEnumType(L, typeof(DG.Tweening.Ease));

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(DG.Tweening.Ease), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushDGTweeningEase(L, (DG.Tweening.Ease)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

                try
				{
                    translator.TranslateToEnumToTop(L, typeof(DG.Tweening.Ease), 1);
				}
				catch (System.Exception e)
				{
					return LuaAPI.luaL_error(L, "cast to " + typeof(DG.Tweening.Ease) + " exception:" + e);
				}

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for DG.Tweening.Ease! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class DGTweeningLoopTypeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(DG.Tweening.LoopType), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(DG.Tweening.LoopType), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(DG.Tweening.LoopType), L, null, 4, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Restart", DG.Tweening.LoopType.Restart);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Yoyo", DG.Tweening.LoopType.Yoyo);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Incremental", DG.Tweening.LoopType.Incremental);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(DG.Tweening.LoopType), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushDGTweeningLoopType(L, (DG.Tweening.LoopType)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Restart"))
                {
                    translator.PushDGTweeningLoopType(L, DG.Tweening.LoopType.Restart);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Yoyo"))
                {
                    translator.PushDGTweeningLoopType(L, DG.Tweening.LoopType.Yoyo);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Incremental"))
                {
                    translator.PushDGTweeningLoopType(L, DG.Tweening.LoopType.Incremental);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for DG.Tweening.LoopType!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for DG.Tweening.LoopType! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class DGTweeningPathModeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(DG.Tweening.PathMode), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(DG.Tweening.PathMode), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(DG.Tweening.PathMode), L, null, 5, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Ignore", DG.Tweening.PathMode.Ignore);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Full3D", DG.Tweening.PathMode.Full3D);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "TopDown2D", DG.Tweening.PathMode.TopDown2D);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Sidescroller2D", DG.Tweening.PathMode.Sidescroller2D);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(DG.Tweening.PathMode), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushDGTweeningPathMode(L, (DG.Tweening.PathMode)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Ignore"))
                {
                    translator.PushDGTweeningPathMode(L, DG.Tweening.PathMode.Ignore);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Full3D"))
                {
                    translator.PushDGTweeningPathMode(L, DG.Tweening.PathMode.Full3D);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "TopDown2D"))
                {
                    translator.PushDGTweeningPathMode(L, DG.Tweening.PathMode.TopDown2D);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Sidescroller2D"))
                {
                    translator.PushDGTweeningPathMode(L, DG.Tweening.PathMode.Sidescroller2D);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for DG.Tweening.PathMode!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for DG.Tweening.PathMode! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class DGTweeningPathTypeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(DG.Tweening.PathType), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(DG.Tweening.PathType), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(DG.Tweening.PathType), L, null, 4, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Linear", DG.Tweening.PathType.Linear);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CatmullRom", DG.Tweening.PathType.CatmullRom);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CubicBezier", DG.Tweening.PathType.CubicBezier);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(DG.Tweening.PathType), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushDGTweeningPathType(L, (DG.Tweening.PathType)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Linear"))
                {
                    translator.PushDGTweeningPathType(L, DG.Tweening.PathType.Linear);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "CatmullRom"))
                {
                    translator.PushDGTweeningPathType(L, DG.Tweening.PathType.CatmullRom);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "CubicBezier"))
                {
                    translator.PushDGTweeningPathType(L, DG.Tweening.PathType.CubicBezier);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for DG.Tweening.PathType!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for DG.Tweening.PathType! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class DGTweeningRotateModeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(DG.Tweening.RotateMode), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(DG.Tweening.RotateMode), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(DG.Tweening.RotateMode), L, null, 5, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Fast", DG.Tweening.RotateMode.Fast);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FastBeyond360", DG.Tweening.RotateMode.FastBeyond360);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "WorldAxisAdd", DG.Tweening.RotateMode.WorldAxisAdd);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LocalAxisAdd", DG.Tweening.RotateMode.LocalAxisAdd);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(DG.Tweening.RotateMode), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushDGTweeningRotateMode(L, (DG.Tweening.RotateMode)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Fast"))
                {
                    translator.PushDGTweeningRotateMode(L, DG.Tweening.RotateMode.Fast);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "FastBeyond360"))
                {
                    translator.PushDGTweeningRotateMode(L, DG.Tweening.RotateMode.FastBeyond360);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "WorldAxisAdd"))
                {
                    translator.PushDGTweeningRotateMode(L, DG.Tweening.RotateMode.WorldAxisAdd);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "LocalAxisAdd"))
                {
                    translator.PushDGTweeningRotateMode(L, DG.Tweening.RotateMode.LocalAxisAdd);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for DG.Tweening.RotateMode!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for DG.Tweening.RotateMode! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEnginePrimitiveTypeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.PrimitiveType), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.PrimitiveType), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.PrimitiveType), L, null, 7, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Sphere", UnityEngine.PrimitiveType.Sphere);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Capsule", UnityEngine.PrimitiveType.Capsule);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Cylinder", UnityEngine.PrimitiveType.Cylinder);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Cube", UnityEngine.PrimitiveType.Cube);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Plane", UnityEngine.PrimitiveType.Plane);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Quad", UnityEngine.PrimitiveType.Quad);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.PrimitiveType), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEnginePrimitiveType(L, (UnityEngine.PrimitiveType)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Sphere"))
                {
                    translator.PushUnityEnginePrimitiveType(L, UnityEngine.PrimitiveType.Sphere);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Capsule"))
                {
                    translator.PushUnityEnginePrimitiveType(L, UnityEngine.PrimitiveType.Capsule);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Cylinder"))
                {
                    translator.PushUnityEnginePrimitiveType(L, UnityEngine.PrimitiveType.Cylinder);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Cube"))
                {
                    translator.PushUnityEnginePrimitiveType(L, UnityEngine.PrimitiveType.Cube);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Plane"))
                {
                    translator.PushUnityEnginePrimitiveType(L, UnityEngine.PrimitiveType.Plane);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Quad"))
                {
                    translator.PushUnityEnginePrimitiveType(L, UnityEngine.PrimitiveType.Quad);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.PrimitiveType!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.PrimitiveType! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineSimulationModeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.SimulationMode), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.SimulationMode), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.SimulationMode), L, null, 4, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FixedUpdate", UnityEngine.SimulationMode.FixedUpdate);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Update", UnityEngine.SimulationMode.Update);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Script", UnityEngine.SimulationMode.Script);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.SimulationMode), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineSimulationMode(L, (UnityEngine.SimulationMode)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "FixedUpdate"))
                {
                    translator.PushUnityEngineSimulationMode(L, UnityEngine.SimulationMode.FixedUpdate);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Update"))
                {
                    translator.PushUnityEngineSimulationMode(L, UnityEngine.SimulationMode.Update);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Script"))
                {
                    translator.PushUnityEngineSimulationMode(L, UnityEngine.SimulationMode.Script);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.SimulationMode!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.SimulationMode! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineRuntimePlatformWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.RuntimePlatform), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.RuntimePlatform), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.RuntimePlatform), L, null, 54, 0, 0);

            Utils.RegisterEnumType(L, typeof(UnityEngine.RuntimePlatform));

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.RuntimePlatform), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineRuntimePlatform(L, (UnityEngine.RuntimePlatform)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

                try
				{
                    translator.TranslateToEnumToTop(L, typeof(UnityEngine.RuntimePlatform), 1);
				}
				catch (System.Exception e)
				{
					return LuaAPI.luaL_error(L, "cast to " + typeof(UnityEngine.RuntimePlatform) + " exception:" + e);
				}

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.RuntimePlatform! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineTextureFormatWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.TextureFormat), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.TextureFormat), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.TextureFormat), L, null, 77, 0, 0);

            Utils.RegisterEnumType(L, typeof(UnityEngine.TextureFormat));

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.TextureFormat), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineTextureFormat(L, (UnityEngine.TextureFormat)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

                try
				{
                    translator.TranslateToEnumToTop(L, typeof(UnityEngine.TextureFormat), 1);
				}
				catch (System.Exception e)
				{
					return LuaAPI.luaL_error(L, "cast to " + typeof(UnityEngine.TextureFormat) + " exception:" + e);
				}

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.TextureFormat! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineRenderModeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.RenderMode), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.RenderMode), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.RenderMode), L, null, 4, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ScreenSpaceOverlay", UnityEngine.RenderMode.ScreenSpaceOverlay);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ScreenSpaceCamera", UnityEngine.RenderMode.ScreenSpaceCamera);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "WorldSpace", UnityEngine.RenderMode.WorldSpace);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.RenderMode), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineRenderMode(L, (UnityEngine.RenderMode)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "ScreenSpaceOverlay"))
                {
                    translator.PushUnityEngineRenderMode(L, UnityEngine.RenderMode.ScreenSpaceOverlay);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "ScreenSpaceCamera"))
                {
                    translator.PushUnityEngineRenderMode(L, UnityEngine.RenderMode.ScreenSpaceCamera);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "WorldSpace"))
                {
                    translator.PushUnityEngineRenderMode(L, UnityEngine.RenderMode.WorldSpace);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.RenderMode!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.RenderMode! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineCameraClearFlagsWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.CameraClearFlags), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.CameraClearFlags), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.CameraClearFlags), L, null, 6, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Skybox", UnityEngine.CameraClearFlags.Skybox);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Color", UnityEngine.CameraClearFlags.Color);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SolidColor", UnityEngine.CameraClearFlags.SolidColor);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Depth", UnityEngine.CameraClearFlags.Depth);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Nothing", UnityEngine.CameraClearFlags.Nothing);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.CameraClearFlags), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineCameraClearFlags(L, (UnityEngine.CameraClearFlags)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Skybox"))
                {
                    translator.PushUnityEngineCameraClearFlags(L, UnityEngine.CameraClearFlags.Skybox);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Color"))
                {
                    translator.PushUnityEngineCameraClearFlags(L, UnityEngine.CameraClearFlags.Color);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "SolidColor"))
                {
                    translator.PushUnityEngineCameraClearFlags(L, UnityEngine.CameraClearFlags.SolidColor);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Depth"))
                {
                    translator.PushUnityEngineCameraClearFlags(L, UnityEngine.CameraClearFlags.Depth);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Nothing"))
                {
                    translator.PushUnityEngineCameraClearFlags(L, UnityEngine.CameraClearFlags.Nothing);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.CameraClearFlags!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.CameraClearFlags! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineLightmapsModeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.LightmapsMode), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.LightmapsMode), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.LightmapsMode), L, null, 7, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NonDirectional", UnityEngine.LightmapsMode.NonDirectional);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CombinedDirectional", UnityEngine.LightmapsMode.CombinedDirectional);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.LightmapsMode), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineLightmapsMode(L, (UnityEngine.LightmapsMode)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "NonDirectional"))
                {
                    translator.PushUnityEngineLightmapsMode(L, UnityEngine.LightmapsMode.NonDirectional);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "CombinedDirectional"))
                {
                    translator.PushUnityEngineLightmapsMode(L, UnityEngine.LightmapsMode.CombinedDirectional);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.LightmapsMode!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.LightmapsMode! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineFogModeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.FogMode), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.FogMode), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.FogMode), L, null, 4, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Linear", UnityEngine.FogMode.Linear);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Exponential", UnityEngine.FogMode.Exponential);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ExponentialSquared", UnityEngine.FogMode.ExponentialSquared);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.FogMode), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineFogMode(L, (UnityEngine.FogMode)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Linear"))
                {
                    translator.PushUnityEngineFogMode(L, UnityEngine.FogMode.Linear);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Exponential"))
                {
                    translator.PushUnityEngineFogMode(L, UnityEngine.FogMode.Exponential);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "ExponentialSquared"))
                {
                    translator.PushUnityEngineFogMode(L, UnityEngine.FogMode.ExponentialSquared);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.FogMode!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.FogMode! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineRenderingDefaultReflectionModeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.Rendering.DefaultReflectionMode), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.Rendering.DefaultReflectionMode), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.Rendering.DefaultReflectionMode), L, null, 3, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Skybox", UnityEngine.Rendering.DefaultReflectionMode.Skybox);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Custom", UnityEngine.Rendering.DefaultReflectionMode.Custom);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.Rendering.DefaultReflectionMode), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineRenderingDefaultReflectionMode(L, (UnityEngine.Rendering.DefaultReflectionMode)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Skybox"))
                {
                    translator.PushUnityEngineRenderingDefaultReflectionMode(L, UnityEngine.Rendering.DefaultReflectionMode.Skybox);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Custom"))
                {
                    translator.PushUnityEngineRenderingDefaultReflectionMode(L, UnityEngine.Rendering.DefaultReflectionMode.Custom);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.Rendering.DefaultReflectionMode!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.Rendering.DefaultReflectionMode! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineRenderingAmbientModeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.Rendering.AmbientMode), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.Rendering.AmbientMode), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.Rendering.AmbientMode), L, null, 5, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Skybox", UnityEngine.Rendering.AmbientMode.Skybox);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Trilight", UnityEngine.Rendering.AmbientMode.Trilight);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Flat", UnityEngine.Rendering.AmbientMode.Flat);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Custom", UnityEngine.Rendering.AmbientMode.Custom);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.Rendering.AmbientMode), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineRenderingAmbientMode(L, (UnityEngine.Rendering.AmbientMode)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Skybox"))
                {
                    translator.PushUnityEngineRenderingAmbientMode(L, UnityEngine.Rendering.AmbientMode.Skybox);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Trilight"))
                {
                    translator.PushUnityEngineRenderingAmbientMode(L, UnityEngine.Rendering.AmbientMode.Trilight);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Flat"))
                {
                    translator.PushUnityEngineRenderingAmbientMode(L, UnityEngine.Rendering.AmbientMode.Flat);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Custom"))
                {
                    translator.PushUnityEngineRenderingAmbientMode(L, UnityEngine.Rendering.AmbientMode.Custom);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.Rendering.AmbientMode!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.Rendering.AmbientMode! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineRenderingReflectionProbeModeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.Rendering.ReflectionProbeMode), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.Rendering.ReflectionProbeMode), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.Rendering.ReflectionProbeMode), L, null, 4, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Baked", UnityEngine.Rendering.ReflectionProbeMode.Baked);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Realtime", UnityEngine.Rendering.ReflectionProbeMode.Realtime);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Custom", UnityEngine.Rendering.ReflectionProbeMode.Custom);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.Rendering.ReflectionProbeMode), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineRenderingReflectionProbeMode(L, (UnityEngine.Rendering.ReflectionProbeMode)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Baked"))
                {
                    translator.PushUnityEngineRenderingReflectionProbeMode(L, UnityEngine.Rendering.ReflectionProbeMode.Baked);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Realtime"))
                {
                    translator.PushUnityEngineRenderingReflectionProbeMode(L, UnityEngine.Rendering.ReflectionProbeMode.Realtime);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Custom"))
                {
                    translator.PushUnityEngineRenderingReflectionProbeMode(L, UnityEngine.Rendering.ReflectionProbeMode.Custom);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.Rendering.ReflectionProbeMode!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.Rendering.ReflectionProbeMode! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class YoozooMarsGotQualityEnumWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(Yoozoo.Mars.Got.QualityEnum), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(Yoozoo.Mars.Got.QualityEnum), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(Yoozoo.Mars.Got.QualityEnum), L, null, 9, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "None", Yoozoo.Mars.Got.QualityEnum.None);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Low", Yoozoo.Mars.Got.QualityEnum.Low);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Medium", Yoozoo.Mars.Got.QualityEnum.Medium);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "High", Yoozoo.Mars.Got.QualityEnum.High);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "VeryHigh", Yoozoo.Mars.Got.QualityEnum.VeryHigh);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Perfect", Yoozoo.Mars.Got.QualityEnum.Perfect);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PC", Yoozoo.Mars.Got.QualityEnum.PC);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Test", Yoozoo.Mars.Got.QualityEnum.Test);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(Yoozoo.Mars.Got.QualityEnum), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushYoozooMarsGotQualityEnum(L, (Yoozoo.Mars.Got.QualityEnum)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "None"))
                {
                    translator.PushYoozooMarsGotQualityEnum(L, Yoozoo.Mars.Got.QualityEnum.None);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Low"))
                {
                    translator.PushYoozooMarsGotQualityEnum(L, Yoozoo.Mars.Got.QualityEnum.Low);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Medium"))
                {
                    translator.PushYoozooMarsGotQualityEnum(L, Yoozoo.Mars.Got.QualityEnum.Medium);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "High"))
                {
                    translator.PushYoozooMarsGotQualityEnum(L, Yoozoo.Mars.Got.QualityEnum.High);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "VeryHigh"))
                {
                    translator.PushYoozooMarsGotQualityEnum(L, Yoozoo.Mars.Got.QualityEnum.VeryHigh);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Perfect"))
                {
                    translator.PushYoozooMarsGotQualityEnum(L, Yoozoo.Mars.Got.QualityEnum.Perfect);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "PC"))
                {
                    translator.PushYoozooMarsGotQualityEnum(L, Yoozoo.Mars.Got.QualityEnum.PC);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Test"))
                {
                    translator.PushYoozooMarsGotQualityEnum(L, Yoozoo.Mars.Got.QualityEnum.Test);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for Yoozoo.Mars.Got.QualityEnum!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for Yoozoo.Mars.Got.QualityEnum! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class YoozooModulesDownloadDownloadWhilePlayingManagerStatusWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(Yoozoo.Modules.Download.DownloadWhilePlayingManager.Status), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(Yoozoo.Modules.Download.DownloadWhilePlayingManager.Status), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(Yoozoo.Modules.Download.DownloadWhilePlayingManager.Status), L, null, 6, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "None", Yoozoo.Modules.Download.DownloadWhilePlayingManager.Status.None);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Initialized", Yoozoo.Modules.Download.DownloadWhilePlayingManager.Status.Initialized);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Downloading", Yoozoo.Modules.Download.DownloadWhilePlayingManager.Status.Downloading);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Finish", Yoozoo.Modules.Download.DownloadWhilePlayingManager.Status.Finish);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Failed", Yoozoo.Modules.Download.DownloadWhilePlayingManager.Status.Failed);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(Yoozoo.Modules.Download.DownloadWhilePlayingManager.Status), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushYoozooModulesDownloadDownloadWhilePlayingManagerStatus(L, (Yoozoo.Modules.Download.DownloadWhilePlayingManager.Status)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "None"))
                {
                    translator.PushYoozooModulesDownloadDownloadWhilePlayingManagerStatus(L, Yoozoo.Modules.Download.DownloadWhilePlayingManager.Status.None);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Initialized"))
                {
                    translator.PushYoozooModulesDownloadDownloadWhilePlayingManagerStatus(L, Yoozoo.Modules.Download.DownloadWhilePlayingManager.Status.Initialized);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Downloading"))
                {
                    translator.PushYoozooModulesDownloadDownloadWhilePlayingManagerStatus(L, Yoozoo.Modules.Download.DownloadWhilePlayingManager.Status.Downloading);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Finish"))
                {
                    translator.PushYoozooModulesDownloadDownloadWhilePlayingManagerStatus(L, Yoozoo.Modules.Download.DownloadWhilePlayingManager.Status.Finish);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Failed"))
                {
                    translator.PushYoozooModulesDownloadDownloadWhilePlayingManagerStatus(L, Yoozoo.Modules.Download.DownloadWhilePlayingManager.Status.Failed);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for Yoozoo.Modules.Download.DownloadWhilePlayingManager.Status!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for Yoozoo.Modules.Download.DownloadWhilePlayingManager.Status! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class YoozooModulesDownloadPreDownloadManagerStatusWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(Yoozoo.Modules.Download.PreDownloadManager.Status), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(Yoozoo.Modules.Download.PreDownloadManager.Status), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(Yoozoo.Modules.Download.PreDownloadManager.Status), L, null, 9, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "None", Yoozoo.Modules.Download.PreDownloadManager.Status.None);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Initializing", Yoozoo.Modules.Download.PreDownloadManager.Status.Initializing);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "InitializeFailed", Yoozoo.Modules.Download.PreDownloadManager.Status.InitializeFailed);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Initialized", Yoozoo.Modules.Download.PreDownloadManager.Status.Initialized);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Pause", Yoozoo.Modules.Download.PreDownloadManager.Status.Pause);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Downloading", Yoozoo.Modules.Download.PreDownloadManager.Status.Downloading);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Finish", Yoozoo.Modules.Download.PreDownloadManager.Status.Finish);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Failed", Yoozoo.Modules.Download.PreDownloadManager.Status.Failed);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(Yoozoo.Modules.Download.PreDownloadManager.Status), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushYoozooModulesDownloadPreDownloadManagerStatus(L, (Yoozoo.Modules.Download.PreDownloadManager.Status)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "None"))
                {
                    translator.PushYoozooModulesDownloadPreDownloadManagerStatus(L, Yoozoo.Modules.Download.PreDownloadManager.Status.None);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Initializing"))
                {
                    translator.PushYoozooModulesDownloadPreDownloadManagerStatus(L, Yoozoo.Modules.Download.PreDownloadManager.Status.Initializing);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "InitializeFailed"))
                {
                    translator.PushYoozooModulesDownloadPreDownloadManagerStatus(L, Yoozoo.Modules.Download.PreDownloadManager.Status.InitializeFailed);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Initialized"))
                {
                    translator.PushYoozooModulesDownloadPreDownloadManagerStatus(L, Yoozoo.Modules.Download.PreDownloadManager.Status.Initialized);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Pause"))
                {
                    translator.PushYoozooModulesDownloadPreDownloadManagerStatus(L, Yoozoo.Modules.Download.PreDownloadManager.Status.Pause);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Downloading"))
                {
                    translator.PushYoozooModulesDownloadPreDownloadManagerStatus(L, Yoozoo.Modules.Download.PreDownloadManager.Status.Downloading);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Finish"))
                {
                    translator.PushYoozooModulesDownloadPreDownloadManagerStatus(L, Yoozoo.Modules.Download.PreDownloadManager.Status.Finish);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Failed"))
                {
                    translator.PushYoozooModulesDownloadPreDownloadManagerStatus(L, Yoozoo.Modules.Download.PreDownloadManager.Status.Failed);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for Yoozoo.Modules.Download.PreDownloadManager.Status!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for Yoozoo.Modules.Download.PreDownloadManager.Status! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class YoozooManagersResourceManagerV2FrameworkResourceResourceModeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(Yoozoo.Managers.ResourceManagerV2.Framework.Resource.ResourceMode), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(Yoozoo.Managers.ResourceManagerV2.Framework.Resource.ResourceMode), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(Yoozoo.Managers.ResourceManagerV2.Framework.Resource.ResourceMode), L, null, 5, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Unspecified", Yoozoo.Managers.ResourceManagerV2.Framework.Resource.ResourceMode.Unspecified);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Package", Yoozoo.Managers.ResourceManagerV2.Framework.Resource.ResourceMode.Package);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Updatable", Yoozoo.Managers.ResourceManagerV2.Framework.Resource.ResourceMode.Updatable);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "UpdatableWhilePlaying", Yoozoo.Managers.ResourceManagerV2.Framework.Resource.ResourceMode.UpdatableWhilePlaying);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(Yoozoo.Managers.ResourceManagerV2.Framework.Resource.ResourceMode), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushYoozooManagersResourceManagerV2FrameworkResourceResourceMode(L, (Yoozoo.Managers.ResourceManagerV2.Framework.Resource.ResourceMode)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Unspecified"))
                {
                    translator.PushYoozooManagersResourceManagerV2FrameworkResourceResourceMode(L, Yoozoo.Managers.ResourceManagerV2.Framework.Resource.ResourceMode.Unspecified);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Package"))
                {
                    translator.PushYoozooManagersResourceManagerV2FrameworkResourceResourceMode(L, Yoozoo.Managers.ResourceManagerV2.Framework.Resource.ResourceMode.Package);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Updatable"))
                {
                    translator.PushYoozooManagersResourceManagerV2FrameworkResourceResourceMode(L, Yoozoo.Managers.ResourceManagerV2.Framework.Resource.ResourceMode.Updatable);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "UpdatableWhilePlaying"))
                {
                    translator.PushYoozooManagersResourceManagerV2FrameworkResourceResourceMode(L, Yoozoo.Managers.ResourceManagerV2.Framework.Resource.ResourceMode.UpdatableWhilePlaying);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for Yoozoo.Managers.ResourceManagerV2.Framework.Resource.ResourceMode!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for Yoozoo.Managers.ResourceManagerV2.Framework.Resource.ResourceMode! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class YoozooGameplayLibertyAIAnimationStateWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(Yoozoo.Gameplay.Liberty.AI.AnimationState), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(Yoozoo.Gameplay.Liberty.AI.AnimationState), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(Yoozoo.Gameplay.Liberty.AI.AnimationState), L, null, 40, 0, 0);

            Utils.RegisterEnumType(L, typeof(Yoozoo.Gameplay.Liberty.AI.AnimationState));

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(Yoozoo.Gameplay.Liberty.AI.AnimationState), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushYoozooGameplayLibertyAIAnimationState(L, (Yoozoo.Gameplay.Liberty.AI.AnimationState)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

                try
				{
                    translator.TranslateToEnumToTop(L, typeof(Yoozoo.Gameplay.Liberty.AI.AnimationState), 1);
				}
				catch (System.Exception e)
				{
					return LuaAPI.luaL_error(L, "cast to " + typeof(Yoozoo.Gameplay.Liberty.AI.AnimationState) + " exception:" + e);
				}

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for Yoozoo.Gameplay.Liberty.AI.AnimationState! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class YoozooGameplayLibertyAIBattleStateWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(Yoozoo.Gameplay.Liberty.AI.BattleState), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(Yoozoo.Gameplay.Liberty.AI.BattleState), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(Yoozoo.Gameplay.Liberty.AI.BattleState), L, null, 7, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "None", Yoozoo.Gameplay.Liberty.AI.BattleState.None);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Boxing", Yoozoo.Gameplay.Liberty.AI.BattleState.Boxing);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "HandGun", Yoozoo.Gameplay.Liberty.AI.BattleState.HandGun);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AutoRifle", Yoozoo.Gameplay.Liberty.AI.BattleState.AutoRifle);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Bomb", Yoozoo.Gameplay.Liberty.AI.BattleState.Bomb);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RPG", Yoozoo.Gameplay.Liberty.AI.BattleState.RPG);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(Yoozoo.Gameplay.Liberty.AI.BattleState), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushYoozooGameplayLibertyAIBattleState(L, (Yoozoo.Gameplay.Liberty.AI.BattleState)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "None"))
                {
                    translator.PushYoozooGameplayLibertyAIBattleState(L, Yoozoo.Gameplay.Liberty.AI.BattleState.None);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Boxing"))
                {
                    translator.PushYoozooGameplayLibertyAIBattleState(L, Yoozoo.Gameplay.Liberty.AI.BattleState.Boxing);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "HandGun"))
                {
                    translator.PushYoozooGameplayLibertyAIBattleState(L, Yoozoo.Gameplay.Liberty.AI.BattleState.HandGun);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "AutoRifle"))
                {
                    translator.PushYoozooGameplayLibertyAIBattleState(L, Yoozoo.Gameplay.Liberty.AI.BattleState.AutoRifle);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Bomb"))
                {
                    translator.PushYoozooGameplayLibertyAIBattleState(L, Yoozoo.Gameplay.Liberty.AI.BattleState.Bomb);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "RPG"))
                {
                    translator.PushYoozooGameplayLibertyAIBattleState(L, Yoozoo.Gameplay.Liberty.AI.BattleState.RPG);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for Yoozoo.Gameplay.Liberty.AI.BattleState!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for Yoozoo.Gameplay.Liberty.AI.BattleState! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class TreeTypeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(TreeType), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(TreeType), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(TreeType), L, null, 5, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LinearQuadTree", TreeType.LinearQuadTree);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LinearOcTree", TreeType.LinearOcTree);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "QuadTree", TreeType.QuadTree);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "OcTree", TreeType.OcTree);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(TreeType), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushTreeType(L, (TreeType)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "LinearQuadTree"))
                {
                    translator.PushTreeType(L, TreeType.LinearQuadTree);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "LinearOcTree"))
                {
                    translator.PushTreeType(L, TreeType.LinearOcTree);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "QuadTree"))
                {
                    translator.PushTreeType(L, TreeType.QuadTree);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "OcTree"))
                {
                    translator.PushTreeType(L, TreeType.OcTree);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for TreeType!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for TreeType! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class SystemEnvironmentSpecialFolderWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(System.Environment.SpecialFolder), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(System.Environment.SpecialFolder), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(System.Environment.SpecialFolder), L, null, 48, 0, 0);

            Utils.RegisterEnumType(L, typeof(System.Environment.SpecialFolder));

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(System.Environment.SpecialFolder), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushSystemEnvironmentSpecialFolder(L, (System.Environment.SpecialFolder)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

                try
				{
                    translator.TranslateToEnumToTop(L, typeof(System.Environment.SpecialFolder), 1);
				}
				catch (System.Exception e)
				{
					return LuaAPI.luaL_error(L, "cast to " + typeof(System.Environment.SpecialFolder) + " exception:" + e);
				}

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for System.Environment.SpecialFolder! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class SystemEnvironmentSpecialFolderOptionWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(System.Environment.SpecialFolderOption), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(System.Environment.SpecialFolderOption), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(System.Environment.SpecialFolderOption), L, null, 4, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "None", System.Environment.SpecialFolderOption.None);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DoNotVerify", System.Environment.SpecialFolderOption.DoNotVerify);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Create", System.Environment.SpecialFolderOption.Create);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(System.Environment.SpecialFolderOption), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushSystemEnvironmentSpecialFolderOption(L, (System.Environment.SpecialFolderOption)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "None"))
                {
                    translator.PushSystemEnvironmentSpecialFolderOption(L, System.Environment.SpecialFolderOption.None);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "DoNotVerify"))
                {
                    translator.PushSystemEnvironmentSpecialFolderOption(L, System.Environment.SpecialFolderOption.DoNotVerify);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Create"))
                {
                    translator.PushSystemEnvironmentSpecialFolderOption(L, System.Environment.SpecialFolderOption.Create);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for System.Environment.SpecialFolderOption!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for System.Environment.SpecialFolderOption! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class WorldEntryMapPointTypeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(WorldEntry.MapPointType), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(WorldEntry.MapPointType), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(WorldEntry.MapPointType), L, null, 18, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "E_Null", WorldEntry.MapPointType.E_Null);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "E_City", WorldEntry.MapPointType.E_City);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "E_Res", WorldEntry.MapPointType.E_Res);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "E_CityAndRes", WorldEntry.MapPointType.E_CityAndRes);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "E_Alliance", WorldEntry.MapPointType.E_Alliance);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "E_Wonder", WorldEntry.MapPointType.E_Wonder);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "E_Checkpoint", WorldEntry.MapPointType.E_Checkpoint);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "E_RallyPoint", WorldEntry.MapPointType.E_RallyPoint);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "E_RaderRpg", WorldEntry.MapPointType.E_RaderRpg);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "E_RaderRts", WorldEntry.MapPointType.E_RaderRts);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "E_WonderPoint_1", WorldEntry.MapPointType.E_WonderPoint_1);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "E_WonderPoint_2", WorldEntry.MapPointType.E_WonderPoint_2);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "E_WonderPoint_3", WorldEntry.MapPointType.E_WonderPoint_3);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "E_StationPoint", WorldEntry.MapPointType.E_StationPoint);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "E_ActivityBuild", WorldEntry.MapPointType.E_ActivityBuild);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "E_Parliament_city", WorldEntry.MapPointType.E_Parliament_city);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "E_EditorResPoint", WorldEntry.MapPointType.E_EditorResPoint);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(WorldEntry.MapPointType), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushWorldEntryMapPointType(L, (WorldEntry.MapPointType)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "E_Null"))
                {
                    translator.PushWorldEntryMapPointType(L, WorldEntry.MapPointType.E_Null);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "E_City"))
                {
                    translator.PushWorldEntryMapPointType(L, WorldEntry.MapPointType.E_City);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "E_Res"))
                {
                    translator.PushWorldEntryMapPointType(L, WorldEntry.MapPointType.E_Res);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "E_CityAndRes"))
                {
                    translator.PushWorldEntryMapPointType(L, WorldEntry.MapPointType.E_CityAndRes);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "E_Alliance"))
                {
                    translator.PushWorldEntryMapPointType(L, WorldEntry.MapPointType.E_Alliance);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "E_Wonder"))
                {
                    translator.PushWorldEntryMapPointType(L, WorldEntry.MapPointType.E_Wonder);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "E_Checkpoint"))
                {
                    translator.PushWorldEntryMapPointType(L, WorldEntry.MapPointType.E_Checkpoint);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "E_RallyPoint"))
                {
                    translator.PushWorldEntryMapPointType(L, WorldEntry.MapPointType.E_RallyPoint);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "E_RaderRpg"))
                {
                    translator.PushWorldEntryMapPointType(L, WorldEntry.MapPointType.E_RaderRpg);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "E_RaderRts"))
                {
                    translator.PushWorldEntryMapPointType(L, WorldEntry.MapPointType.E_RaderRts);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "E_WonderPoint_1"))
                {
                    translator.PushWorldEntryMapPointType(L, WorldEntry.MapPointType.E_WonderPoint_1);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "E_WonderPoint_2"))
                {
                    translator.PushWorldEntryMapPointType(L, WorldEntry.MapPointType.E_WonderPoint_2);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "E_WonderPoint_3"))
                {
                    translator.PushWorldEntryMapPointType(L, WorldEntry.MapPointType.E_WonderPoint_3);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "E_StationPoint"))
                {
                    translator.PushWorldEntryMapPointType(L, WorldEntry.MapPointType.E_StationPoint);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "E_ActivityBuild"))
                {
                    translator.PushWorldEntryMapPointType(L, WorldEntry.MapPointType.E_ActivityBuild);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "E_Parliament_city"))
                {
                    translator.PushWorldEntryMapPointType(L, WorldEntry.MapPointType.E_Parliament_city);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "E_EditorResPoint"))
                {
                    translator.PushWorldEntryMapPointType(L, WorldEntry.MapPointType.E_EditorResPoint);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for WorldEntry.MapPointType!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for WorldEntry.MapPointType! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class YoozooManagerTouchManagerRaycastTargetWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(Yoozoo.Manager.TouchManager.RaycastTarget), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(Yoozoo.Manager.TouchManager.RaycastTarget), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(Yoozoo.Manager.TouchManager.RaycastTarget), L, null, 3, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CITY_ITEM", Yoozoo.Manager.TouchManager.RaycastTarget.CITY_ITEM);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CITY_GROUND", Yoozoo.Manager.TouchManager.RaycastTarget.CITY_GROUND);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(Yoozoo.Manager.TouchManager.RaycastTarget), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushYoozooManagerTouchManagerRaycastTarget(L, (Yoozoo.Manager.TouchManager.RaycastTarget)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "CITY_ITEM"))
                {
                    translator.PushYoozooManagerTouchManagerRaycastTarget(L, Yoozoo.Manager.TouchManager.RaycastTarget.CITY_ITEM);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "CITY_GROUND"))
                {
                    translator.PushYoozooManagerTouchManagerRaycastTarget(L, Yoozoo.Manager.TouchManager.RaycastTarget.CITY_GROUND);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for Yoozoo.Manager.TouchManager.RaycastTarget!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for Yoozoo.Manager.TouchManager.RaycastTarget! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineRectTransformEdgeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.RectTransform.Edge), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.RectTransform.Edge), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.RectTransform.Edge), L, null, 5, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Left", UnityEngine.RectTransform.Edge.Left);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Right", UnityEngine.RectTransform.Edge.Right);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Top", UnityEngine.RectTransform.Edge.Top);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Bottom", UnityEngine.RectTransform.Edge.Bottom);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.RectTransform.Edge), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineRectTransformEdge(L, (UnityEngine.RectTransform.Edge)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Left"))
                {
                    translator.PushUnityEngineRectTransformEdge(L, UnityEngine.RectTransform.Edge.Left);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Right"))
                {
                    translator.PushUnityEngineRectTransformEdge(L, UnityEngine.RectTransform.Edge.Right);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Top"))
                {
                    translator.PushUnityEngineRectTransformEdge(L, UnityEngine.RectTransform.Edge.Top);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Bottom"))
                {
                    translator.PushUnityEngineRectTransformEdge(L, UnityEngine.RectTransform.Edge.Bottom);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.RectTransform.Edge!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.RectTransform.Edge! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineRectTransformAxisWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.RectTransform.Axis), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.RectTransform.Axis), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.RectTransform.Axis), L, null, 3, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Horizontal", UnityEngine.RectTransform.Axis.Horizontal);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Vertical", UnityEngine.RectTransform.Axis.Vertical);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.RectTransform.Axis), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineRectTransformAxis(L, (UnityEngine.RectTransform.Axis)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Horizontal"))
                {
                    translator.PushUnityEngineRectTransformAxis(L, UnityEngine.RectTransform.Axis.Horizontal);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Vertical"))
                {
                    translator.PushUnityEngineRectTransformAxis(L, UnityEngine.RectTransform.Axis.Vertical);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.RectTransform.Axis!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.RectTransform.Axis! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineTexture2DEXRFlagsWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.Texture2D.EXRFlags), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.Texture2D.EXRFlags), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.Texture2D.EXRFlags), L, null, 6, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "None", UnityEngine.Texture2D.EXRFlags.None);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "OutputAsFloat", UnityEngine.Texture2D.EXRFlags.OutputAsFloat);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CompressZIP", UnityEngine.Texture2D.EXRFlags.CompressZIP);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CompressRLE", UnityEngine.Texture2D.EXRFlags.CompressRLE);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CompressPIZ", UnityEngine.Texture2D.EXRFlags.CompressPIZ);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.Texture2D.EXRFlags), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineTexture2DEXRFlags(L, (UnityEngine.Texture2D.EXRFlags)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "None"))
                {
                    translator.PushUnityEngineTexture2DEXRFlags(L, UnityEngine.Texture2D.EXRFlags.None);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "OutputAsFloat"))
                {
                    translator.PushUnityEngineTexture2DEXRFlags(L, UnityEngine.Texture2D.EXRFlags.OutputAsFloat);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "CompressZIP"))
                {
                    translator.PushUnityEngineTexture2DEXRFlags(L, UnityEngine.Texture2D.EXRFlags.CompressZIP);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "CompressRLE"))
                {
                    translator.PushUnityEngineTexture2DEXRFlags(L, UnityEngine.Texture2D.EXRFlags.CompressRLE);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "CompressPIZ"))
                {
                    translator.PushUnityEngineTexture2DEXRFlags(L, UnityEngine.Texture2D.EXRFlags.CompressPIZ);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.Texture2D.EXRFlags!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.Texture2D.EXRFlags! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineUIScrollRectMovementTypeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.UI.ScrollRect.MovementType), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.UI.ScrollRect.MovementType), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.UI.ScrollRect.MovementType), L, null, 4, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Unrestricted", UnityEngine.UI.ScrollRect.MovementType.Unrestricted);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Elastic", UnityEngine.UI.ScrollRect.MovementType.Elastic);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Clamped", UnityEngine.UI.ScrollRect.MovementType.Clamped);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.UI.ScrollRect.MovementType), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineUIScrollRectMovementType(L, (UnityEngine.UI.ScrollRect.MovementType)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Unrestricted"))
                {
                    translator.PushUnityEngineUIScrollRectMovementType(L, UnityEngine.UI.ScrollRect.MovementType.Unrestricted);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Elastic"))
                {
                    translator.PushUnityEngineUIScrollRectMovementType(L, UnityEngine.UI.ScrollRect.MovementType.Elastic);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Clamped"))
                {
                    translator.PushUnityEngineUIScrollRectMovementType(L, UnityEngine.UI.ScrollRect.MovementType.Clamped);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.UI.ScrollRect.MovementType!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.UI.ScrollRect.MovementType! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineUIScrollRectScrollbarVisibilityWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.UI.ScrollRect.ScrollbarVisibility), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.UI.ScrollRect.ScrollbarVisibility), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.UI.ScrollRect.ScrollbarVisibility), L, null, 4, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Permanent", UnityEngine.UI.ScrollRect.ScrollbarVisibility.Permanent);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AutoHide", UnityEngine.UI.ScrollRect.ScrollbarVisibility.AutoHide);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AutoHideAndExpandViewport", UnityEngine.UI.ScrollRect.ScrollbarVisibility.AutoHideAndExpandViewport);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.UI.ScrollRect.ScrollbarVisibility), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineUIScrollRectScrollbarVisibility(L, (UnityEngine.UI.ScrollRect.ScrollbarVisibility)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Permanent"))
                {
                    translator.PushUnityEngineUIScrollRectScrollbarVisibility(L, UnityEngine.UI.ScrollRect.ScrollbarVisibility.Permanent);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "AutoHide"))
                {
                    translator.PushUnityEngineUIScrollRectScrollbarVisibility(L, UnityEngine.UI.ScrollRect.ScrollbarVisibility.AutoHide);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "AutoHideAndExpandViewport"))
                {
                    translator.PushUnityEngineUIScrollRectScrollbarVisibility(L, UnityEngine.UI.ScrollRect.ScrollbarVisibility.AutoHideAndExpandViewport);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.UI.ScrollRect.ScrollbarVisibility!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.UI.ScrollRect.ScrollbarVisibility! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineUIGridLayoutGroupCornerWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.UI.GridLayoutGroup.Corner), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.UI.GridLayoutGroup.Corner), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.UI.GridLayoutGroup.Corner), L, null, 5, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "UpperLeft", UnityEngine.UI.GridLayoutGroup.Corner.UpperLeft);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "UpperRight", UnityEngine.UI.GridLayoutGroup.Corner.UpperRight);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LowerLeft", UnityEngine.UI.GridLayoutGroup.Corner.LowerLeft);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LowerRight", UnityEngine.UI.GridLayoutGroup.Corner.LowerRight);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.UI.GridLayoutGroup.Corner), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineUIGridLayoutGroupCorner(L, (UnityEngine.UI.GridLayoutGroup.Corner)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "UpperLeft"))
                {
                    translator.PushUnityEngineUIGridLayoutGroupCorner(L, UnityEngine.UI.GridLayoutGroup.Corner.UpperLeft);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "UpperRight"))
                {
                    translator.PushUnityEngineUIGridLayoutGroupCorner(L, UnityEngine.UI.GridLayoutGroup.Corner.UpperRight);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "LowerLeft"))
                {
                    translator.PushUnityEngineUIGridLayoutGroupCorner(L, UnityEngine.UI.GridLayoutGroup.Corner.LowerLeft);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "LowerRight"))
                {
                    translator.PushUnityEngineUIGridLayoutGroupCorner(L, UnityEngine.UI.GridLayoutGroup.Corner.LowerRight);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.UI.GridLayoutGroup.Corner!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.UI.GridLayoutGroup.Corner! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineUIGridLayoutGroupAxisWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.UI.GridLayoutGroup.Axis), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.UI.GridLayoutGroup.Axis), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.UI.GridLayoutGroup.Axis), L, null, 3, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Horizontal", UnityEngine.UI.GridLayoutGroup.Axis.Horizontal);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Vertical", UnityEngine.UI.GridLayoutGroup.Axis.Vertical);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.UI.GridLayoutGroup.Axis), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineUIGridLayoutGroupAxis(L, (UnityEngine.UI.GridLayoutGroup.Axis)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Horizontal"))
                {
                    translator.PushUnityEngineUIGridLayoutGroupAxis(L, UnityEngine.UI.GridLayoutGroup.Axis.Horizontal);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Vertical"))
                {
                    translator.PushUnityEngineUIGridLayoutGroupAxis(L, UnityEngine.UI.GridLayoutGroup.Axis.Vertical);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.UI.GridLayoutGroup.Axis!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.UI.GridLayoutGroup.Axis! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineUIGridLayoutGroupConstraintWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.UI.GridLayoutGroup.Constraint), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.UI.GridLayoutGroup.Constraint), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.UI.GridLayoutGroup.Constraint), L, null, 4, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Flexible", UnityEngine.UI.GridLayoutGroup.Constraint.Flexible);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FixedColumnCount", UnityEngine.UI.GridLayoutGroup.Constraint.FixedColumnCount);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FixedRowCount", UnityEngine.UI.GridLayoutGroup.Constraint.FixedRowCount);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.UI.GridLayoutGroup.Constraint), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineUIGridLayoutGroupConstraint(L, (UnityEngine.UI.GridLayoutGroup.Constraint)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Flexible"))
                {
                    translator.PushUnityEngineUIGridLayoutGroupConstraint(L, UnityEngine.UI.GridLayoutGroup.Constraint.Flexible);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "FixedColumnCount"))
                {
                    translator.PushUnityEngineUIGridLayoutGroupConstraint(L, UnityEngine.UI.GridLayoutGroup.Constraint.FixedColumnCount);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "FixedRowCount"))
                {
                    translator.PushUnityEngineUIGridLayoutGroupConstraint(L, UnityEngine.UI.GridLayoutGroup.Constraint.FixedRowCount);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.UI.GridLayoutGroup.Constraint!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.UI.GridLayoutGroup.Constraint! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineUIContentSizeFitterFitModeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.UI.ContentSizeFitter.FitMode), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.UI.ContentSizeFitter.FitMode), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.UI.ContentSizeFitter.FitMode), L, null, 4, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Unconstrained", UnityEngine.UI.ContentSizeFitter.FitMode.Unconstrained);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MinSize", UnityEngine.UI.ContentSizeFitter.FitMode.MinSize);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PreferredSize", UnityEngine.UI.ContentSizeFitter.FitMode.PreferredSize);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.UI.ContentSizeFitter.FitMode), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineUIContentSizeFitterFitMode(L, (UnityEngine.UI.ContentSizeFitter.FitMode)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Unconstrained"))
                {
                    translator.PushUnityEngineUIContentSizeFitterFitMode(L, UnityEngine.UI.ContentSizeFitter.FitMode.Unconstrained);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "MinSize"))
                {
                    translator.PushUnityEngineUIContentSizeFitterFitMode(L, UnityEngine.UI.ContentSizeFitter.FitMode.MinSize);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "PreferredSize"))
                {
                    translator.PushUnityEngineUIContentSizeFitterFitMode(L, UnityEngine.UI.ContentSizeFitter.FitMode.PreferredSize);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.UI.ContentSizeFitter.FitMode!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.UI.ContentSizeFitter.FitMode! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineUIInputFieldContentTypeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.UI.InputField.ContentType), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.UI.InputField.ContentType), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.UI.InputField.ContentType), L, null, 11, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Standard", UnityEngine.UI.InputField.ContentType.Standard);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Autocorrected", UnityEngine.UI.InputField.ContentType.Autocorrected);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "IntegerNumber", UnityEngine.UI.InputField.ContentType.IntegerNumber);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DecimalNumber", UnityEngine.UI.InputField.ContentType.DecimalNumber);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Alphanumeric", UnityEngine.UI.InputField.ContentType.Alphanumeric);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Name", UnityEngine.UI.InputField.ContentType.Name);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "EmailAddress", UnityEngine.UI.InputField.ContentType.EmailAddress);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Password", UnityEngine.UI.InputField.ContentType.Password);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Pin", UnityEngine.UI.InputField.ContentType.Pin);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Custom", UnityEngine.UI.InputField.ContentType.Custom);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.UI.InputField.ContentType), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineUIInputFieldContentType(L, (UnityEngine.UI.InputField.ContentType)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Standard"))
                {
                    translator.PushUnityEngineUIInputFieldContentType(L, UnityEngine.UI.InputField.ContentType.Standard);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Autocorrected"))
                {
                    translator.PushUnityEngineUIInputFieldContentType(L, UnityEngine.UI.InputField.ContentType.Autocorrected);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "IntegerNumber"))
                {
                    translator.PushUnityEngineUIInputFieldContentType(L, UnityEngine.UI.InputField.ContentType.IntegerNumber);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "DecimalNumber"))
                {
                    translator.PushUnityEngineUIInputFieldContentType(L, UnityEngine.UI.InputField.ContentType.DecimalNumber);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Alphanumeric"))
                {
                    translator.PushUnityEngineUIInputFieldContentType(L, UnityEngine.UI.InputField.ContentType.Alphanumeric);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Name"))
                {
                    translator.PushUnityEngineUIInputFieldContentType(L, UnityEngine.UI.InputField.ContentType.Name);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "EmailAddress"))
                {
                    translator.PushUnityEngineUIInputFieldContentType(L, UnityEngine.UI.InputField.ContentType.EmailAddress);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Password"))
                {
                    translator.PushUnityEngineUIInputFieldContentType(L, UnityEngine.UI.InputField.ContentType.Password);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Pin"))
                {
                    translator.PushUnityEngineUIInputFieldContentType(L, UnityEngine.UI.InputField.ContentType.Pin);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Custom"))
                {
                    translator.PushUnityEngineUIInputFieldContentType(L, UnityEngine.UI.InputField.ContentType.Custom);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.UI.InputField.ContentType!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.UI.InputField.ContentType! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineUIInputFieldInputTypeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.UI.InputField.InputType), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.UI.InputField.InputType), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.UI.InputField.InputType), L, null, 4, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Standard", UnityEngine.UI.InputField.InputType.Standard);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AutoCorrect", UnityEngine.UI.InputField.InputType.AutoCorrect);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Password", UnityEngine.UI.InputField.InputType.Password);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.UI.InputField.InputType), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineUIInputFieldInputType(L, (UnityEngine.UI.InputField.InputType)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Standard"))
                {
                    translator.PushUnityEngineUIInputFieldInputType(L, UnityEngine.UI.InputField.InputType.Standard);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "AutoCorrect"))
                {
                    translator.PushUnityEngineUIInputFieldInputType(L, UnityEngine.UI.InputField.InputType.AutoCorrect);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Password"))
                {
                    translator.PushUnityEngineUIInputFieldInputType(L, UnityEngine.UI.InputField.InputType.Password);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.UI.InputField.InputType!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.UI.InputField.InputType! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineUIInputFieldCharacterValidationWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.UI.InputField.CharacterValidation), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.UI.InputField.CharacterValidation), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.UI.InputField.CharacterValidation), L, null, 7, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "None", UnityEngine.UI.InputField.CharacterValidation.None);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Integer", UnityEngine.UI.InputField.CharacterValidation.Integer);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Decimal", UnityEngine.UI.InputField.CharacterValidation.Decimal);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Alphanumeric", UnityEngine.UI.InputField.CharacterValidation.Alphanumeric);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Name", UnityEngine.UI.InputField.CharacterValidation.Name);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "EmailAddress", UnityEngine.UI.InputField.CharacterValidation.EmailAddress);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.UI.InputField.CharacterValidation), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineUIInputFieldCharacterValidation(L, (UnityEngine.UI.InputField.CharacterValidation)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "None"))
                {
                    translator.PushUnityEngineUIInputFieldCharacterValidation(L, UnityEngine.UI.InputField.CharacterValidation.None);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Integer"))
                {
                    translator.PushUnityEngineUIInputFieldCharacterValidation(L, UnityEngine.UI.InputField.CharacterValidation.Integer);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Decimal"))
                {
                    translator.PushUnityEngineUIInputFieldCharacterValidation(L, UnityEngine.UI.InputField.CharacterValidation.Decimal);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Alphanumeric"))
                {
                    translator.PushUnityEngineUIInputFieldCharacterValidation(L, UnityEngine.UI.InputField.CharacterValidation.Alphanumeric);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Name"))
                {
                    translator.PushUnityEngineUIInputFieldCharacterValidation(L, UnityEngine.UI.InputField.CharacterValidation.Name);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "EmailAddress"))
                {
                    translator.PushUnityEngineUIInputFieldCharacterValidation(L, UnityEngine.UI.InputField.CharacterValidation.EmailAddress);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.UI.InputField.CharacterValidation!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.UI.InputField.CharacterValidation! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineUIInputFieldLineTypeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.UI.InputField.LineType), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.UI.InputField.LineType), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.UI.InputField.LineType), L, null, 4, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SingleLine", UnityEngine.UI.InputField.LineType.SingleLine);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MultiLineSubmit", UnityEngine.UI.InputField.LineType.MultiLineSubmit);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MultiLineNewline", UnityEngine.UI.InputField.LineType.MultiLineNewline);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.UI.InputField.LineType), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineUIInputFieldLineType(L, (UnityEngine.UI.InputField.LineType)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "SingleLine"))
                {
                    translator.PushUnityEngineUIInputFieldLineType(L, UnityEngine.UI.InputField.LineType.SingleLine);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "MultiLineSubmit"))
                {
                    translator.PushUnityEngineUIInputFieldLineType(L, UnityEngine.UI.InputField.LineType.MultiLineSubmit);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "MultiLineNewline"))
                {
                    translator.PushUnityEngineUIInputFieldLineType(L, UnityEngine.UI.InputField.LineType.MultiLineNewline);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.UI.InputField.LineType!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.UI.InputField.LineType! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class YoozooUIYGUIYListDirectionWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(Yoozoo.UI.YGUI.YList.Direction), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(Yoozoo.UI.YGUI.YList.Direction), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(Yoozoo.UI.YGUI.YList.Direction), L, null, 3, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Horizontal", Yoozoo.UI.YGUI.YList.Direction.Horizontal);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Vertical", Yoozoo.UI.YGUI.YList.Direction.Vertical);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(Yoozoo.UI.YGUI.YList.Direction), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushYoozooUIYGUIYListDirection(L, (Yoozoo.UI.YGUI.YList.Direction)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Horizontal"))
                {
                    translator.PushYoozooUIYGUIYListDirection(L, Yoozoo.UI.YGUI.YList.Direction.Horizontal);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Vertical"))
                {
                    translator.PushYoozooUIYGUIYListDirection(L, Yoozoo.UI.YGUI.YList.Direction.Vertical);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for Yoozoo.UI.YGUI.YList.Direction!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for Yoozoo.UI.YGUI.YList.Direction! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class YoozooUIYGUIYSliderDirectionWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(Yoozoo.UI.YGUI.YSlider.Direction), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(Yoozoo.UI.YGUI.YSlider.Direction), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(Yoozoo.UI.YGUI.YSlider.Direction), L, null, 5, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LeftToRight", Yoozoo.UI.YGUI.YSlider.Direction.LeftToRight);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RightToLeft", Yoozoo.UI.YGUI.YSlider.Direction.RightToLeft);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BottomToTop", Yoozoo.UI.YGUI.YSlider.Direction.BottomToTop);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "TopToBottom", Yoozoo.UI.YGUI.YSlider.Direction.TopToBottom);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(Yoozoo.UI.YGUI.YSlider.Direction), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushYoozooUIYGUIYSliderDirection(L, (Yoozoo.UI.YGUI.YSlider.Direction)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "LeftToRight"))
                {
                    translator.PushYoozooUIYGUIYSliderDirection(L, Yoozoo.UI.YGUI.YSlider.Direction.LeftToRight);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "RightToLeft"))
                {
                    translator.PushYoozooUIYGUIYSliderDirection(L, Yoozoo.UI.YGUI.YSlider.Direction.RightToLeft);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "BottomToTop"))
                {
                    translator.PushYoozooUIYGUIYSliderDirection(L, Yoozoo.UI.YGUI.YSlider.Direction.BottomToTop);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "TopToBottom"))
                {
                    translator.PushYoozooUIYGUIYSliderDirection(L, Yoozoo.UI.YGUI.YSlider.Direction.TopToBottom);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for Yoozoo.UI.YGUI.YSlider.Direction!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for Yoozoo.UI.YGUI.YSlider.Direction! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class YoozooUIYGUIYSliderTextTypeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(Yoozoo.UI.YGUI.YSlider.TextType), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(Yoozoo.UI.YGUI.YSlider.TextType), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(Yoozoo.UI.YGUI.YSlider.TextType), L, null, 3, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Percent", Yoozoo.UI.YGUI.YSlider.TextType.Percent);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Value", Yoozoo.UI.YGUI.YSlider.TextType.Value);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(Yoozoo.UI.YGUI.YSlider.TextType), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushYoozooUIYGUIYSliderTextType(L, (Yoozoo.UI.YGUI.YSlider.TextType)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Percent"))
                {
                    translator.PushYoozooUIYGUIYSliderTextType(L, Yoozoo.UI.YGUI.YSlider.TextType.Percent);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Value"))
                {
                    translator.PushYoozooUIYGUIYSliderTextType(L, Yoozoo.UI.YGUI.YSlider.TextType.Value);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for Yoozoo.UI.YGUI.YSlider.TextType!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for Yoozoo.UI.YGUI.YSlider.TextType! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class YoozooUIYGUIYRichTextLineAlignmentWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(Yoozoo.UI.YGUI.YRichText.LineAlignment), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(Yoozoo.UI.YGUI.YRichText.LineAlignment), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(Yoozoo.UI.YGUI.YRichText.LineAlignment), L, null, 4, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Down", Yoozoo.UI.YGUI.YRichText.LineAlignment.Down);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Mid", Yoozoo.UI.YGUI.YRichText.LineAlignment.Mid);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Up", Yoozoo.UI.YGUI.YRichText.LineAlignment.Up);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(Yoozoo.UI.YGUI.YRichText.LineAlignment), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushYoozooUIYGUIYRichTextLineAlignment(L, (Yoozoo.UI.YGUI.YRichText.LineAlignment)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Down"))
                {
                    translator.PushYoozooUIYGUIYRichTextLineAlignment(L, Yoozoo.UI.YGUI.YRichText.LineAlignment.Down);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Mid"))
                {
                    translator.PushYoozooUIYGUIYRichTextLineAlignment(L, Yoozoo.UI.YGUI.YRichText.LineAlignment.Mid);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Up"))
                {
                    translator.PushYoozooUIYGUIYRichTextLineAlignment(L, Yoozoo.UI.YGUI.YRichText.LineAlignment.Up);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for Yoozoo.UI.YGUI.YRichText.LineAlignment!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for Yoozoo.UI.YGUI.YRichText.LineAlignment! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class YoozooUIYGUIYRichUnderlineTextLineAlignmentWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(Yoozoo.UI.YGUI.YRichUnderlineText.LineAlignment), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(Yoozoo.UI.YGUI.YRichUnderlineText.LineAlignment), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(Yoozoo.UI.YGUI.YRichUnderlineText.LineAlignment), L, null, 4, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Down", Yoozoo.UI.YGUI.YRichUnderlineText.LineAlignment.Down);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Mid", Yoozoo.UI.YGUI.YRichUnderlineText.LineAlignment.Mid);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Up", Yoozoo.UI.YGUI.YRichUnderlineText.LineAlignment.Up);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(Yoozoo.UI.YGUI.YRichUnderlineText.LineAlignment), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushYoozooUIYGUIYRichUnderlineTextLineAlignment(L, (Yoozoo.UI.YGUI.YRichUnderlineText.LineAlignment)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Down"))
                {
                    translator.PushYoozooUIYGUIYRichUnderlineTextLineAlignment(L, Yoozoo.UI.YGUI.YRichUnderlineText.LineAlignment.Down);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Mid"))
                {
                    translator.PushYoozooUIYGUIYRichUnderlineTextLineAlignment(L, Yoozoo.UI.YGUI.YRichUnderlineText.LineAlignment.Mid);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Up"))
                {
                    translator.PushYoozooUIYGUIYRichUnderlineTextLineAlignment(L, Yoozoo.UI.YGUI.YRichUnderlineText.LineAlignment.Up);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for Yoozoo.UI.YGUI.YRichUnderlineText.LineAlignment!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for Yoozoo.UI.YGUI.YRichUnderlineText.LineAlignment! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class GameplayPVEAStarMgrEShapeTypeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(Gameplay.PVE.AStarMgr.EShapeType), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(Gameplay.PVE.AStarMgr.EShapeType), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(Gameplay.PVE.AStarMgr.EShapeType), L, null, 3, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "round", Gameplay.PVE.AStarMgr.EShapeType.round);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "rectange", Gameplay.PVE.AStarMgr.EShapeType.rectange);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(Gameplay.PVE.AStarMgr.EShapeType), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushGameplayPVEAStarMgrEShapeType(L, (Gameplay.PVE.AStarMgr.EShapeType)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "round"))
                {
                    translator.PushGameplayPVEAStarMgrEShapeType(L, Gameplay.PVE.AStarMgr.EShapeType.round);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "rectange"))
                {
                    translator.PushGameplayPVEAStarMgrEShapeType(L, Gameplay.PVE.AStarMgr.EShapeType.rectange);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for Gameplay.PVE.AStarMgr.EShapeType!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for Gameplay.PVE.AStarMgr.EShapeType! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineCameraGateFitModeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.Camera.GateFitMode), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.Camera.GateFitMode), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.Camera.GateFitMode), L, null, 6, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Vertical", UnityEngine.Camera.GateFitMode.Vertical);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Horizontal", UnityEngine.Camera.GateFitMode.Horizontal);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Fill", UnityEngine.Camera.GateFitMode.Fill);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Overscan", UnityEngine.Camera.GateFitMode.Overscan);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "None", UnityEngine.Camera.GateFitMode.None);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.Camera.GateFitMode), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineCameraGateFitMode(L, (UnityEngine.Camera.GateFitMode)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Vertical"))
                {
                    translator.PushUnityEngineCameraGateFitMode(L, UnityEngine.Camera.GateFitMode.Vertical);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Horizontal"))
                {
                    translator.PushUnityEngineCameraGateFitMode(L, UnityEngine.Camera.GateFitMode.Horizontal);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Fill"))
                {
                    translator.PushUnityEngineCameraGateFitMode(L, UnityEngine.Camera.GateFitMode.Fill);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Overscan"))
                {
                    translator.PushUnityEngineCameraGateFitMode(L, UnityEngine.Camera.GateFitMode.Overscan);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "None"))
                {
                    translator.PushUnityEngineCameraGateFitMode(L, UnityEngine.Camera.GateFitMode.None);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.Camera.GateFitMode!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.Camera.GateFitMode! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineCameraFieldOfViewAxisWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.Camera.FieldOfViewAxis), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.Camera.FieldOfViewAxis), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.Camera.FieldOfViewAxis), L, null, 3, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Vertical", UnityEngine.Camera.FieldOfViewAxis.Vertical);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Horizontal", UnityEngine.Camera.FieldOfViewAxis.Horizontal);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.Camera.FieldOfViewAxis), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineCameraFieldOfViewAxis(L, (UnityEngine.Camera.FieldOfViewAxis)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Vertical"))
                {
                    translator.PushUnityEngineCameraFieldOfViewAxis(L, UnityEngine.Camera.FieldOfViewAxis.Vertical);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Horizontal"))
                {
                    translator.PushUnityEngineCameraFieldOfViewAxis(L, UnityEngine.Camera.FieldOfViewAxis.Horizontal);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.Camera.FieldOfViewAxis!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.Camera.FieldOfViewAxis! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineCameraStereoscopicEyeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.Camera.StereoscopicEye), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.Camera.StereoscopicEye), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.Camera.StereoscopicEye), L, null, 3, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Left", UnityEngine.Camera.StereoscopicEye.Left);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Right", UnityEngine.Camera.StereoscopicEye.Right);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.Camera.StereoscopicEye), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineCameraStereoscopicEye(L, (UnityEngine.Camera.StereoscopicEye)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Left"))
                {
                    translator.PushUnityEngineCameraStereoscopicEye(L, UnityEngine.Camera.StereoscopicEye.Left);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Right"))
                {
                    translator.PushUnityEngineCameraStereoscopicEye(L, UnityEngine.Camera.StereoscopicEye.Right);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.Camera.StereoscopicEye!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.Camera.StereoscopicEye! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineCameraMonoOrStereoscopicEyeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.Camera.MonoOrStereoscopicEye), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.Camera.MonoOrStereoscopicEye), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.Camera.MonoOrStereoscopicEye), L, null, 4, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Left", UnityEngine.Camera.MonoOrStereoscopicEye.Left);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Right", UnityEngine.Camera.MonoOrStereoscopicEye.Right);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Mono", UnityEngine.Camera.MonoOrStereoscopicEye.Mono);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.Camera.MonoOrStereoscopicEye), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineCameraMonoOrStereoscopicEye(L, (UnityEngine.Camera.MonoOrStereoscopicEye)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Left"))
                {
                    translator.PushUnityEngineCameraMonoOrStereoscopicEye(L, UnityEngine.Camera.MonoOrStereoscopicEye.Left);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Right"))
                {
                    translator.PushUnityEngineCameraMonoOrStereoscopicEye(L, UnityEngine.Camera.MonoOrStereoscopicEye.Right);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Mono"))
                {
                    translator.PushUnityEngineCameraMonoOrStereoscopicEye(L, UnityEngine.Camera.MonoOrStereoscopicEye.Mono);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.Camera.MonoOrStereoscopicEye!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.Camera.MonoOrStereoscopicEye! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class YoozooUIYGUIListViewListSelectionModeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(Yoozoo.UI.YGUI.ListView.ListSelectionMode), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(Yoozoo.UI.YGUI.ListView.ListSelectionMode), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(Yoozoo.UI.YGUI.ListView.ListSelectionMode), L, null, 4, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "None", Yoozoo.UI.YGUI.ListView.ListSelectionMode.None);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Single", Yoozoo.UI.YGUI.ListView.ListSelectionMode.Single);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Multiple", Yoozoo.UI.YGUI.ListView.ListSelectionMode.Multiple);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(Yoozoo.UI.YGUI.ListView.ListSelectionMode), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushYoozooUIYGUIListViewListSelectionMode(L, (Yoozoo.UI.YGUI.ListView.ListSelectionMode)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "None"))
                {
                    translator.PushYoozooUIYGUIListViewListSelectionMode(L, Yoozoo.UI.YGUI.ListView.ListSelectionMode.None);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Single"))
                {
                    translator.PushYoozooUIYGUIListViewListSelectionMode(L, Yoozoo.UI.YGUI.ListView.ListSelectionMode.Single);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Multiple"))
                {
                    translator.PushYoozooUIYGUIListViewListSelectionMode(L, Yoozoo.UI.YGUI.ListView.ListSelectionMode.Multiple);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for Yoozoo.UI.YGUI.ListView.ListSelectionMode!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for Yoozoo.UI.YGUI.ListView.ListSelectionMode! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class YoozooUIYGUIListViewListLayoutTypeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(Yoozoo.UI.YGUI.ListView.ListLayoutType), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(Yoozoo.UI.YGUI.ListView.ListLayoutType), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(Yoozoo.UI.YGUI.ListView.ListLayoutType), L, null, 6, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SingleColumn", Yoozoo.UI.YGUI.ListView.ListLayoutType.SingleColumn);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SingleRow", Yoozoo.UI.YGUI.ListView.ListLayoutType.SingleRow);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FlowHorizontal", Yoozoo.UI.YGUI.ListView.ListLayoutType.FlowHorizontal);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FlowVertical", Yoozoo.UI.YGUI.ListView.ListLayoutType.FlowVertical);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Pagination", Yoozoo.UI.YGUI.ListView.ListLayoutType.Pagination);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(Yoozoo.UI.YGUI.ListView.ListLayoutType), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushYoozooUIYGUIListViewListLayoutType(L, (Yoozoo.UI.YGUI.ListView.ListLayoutType)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "SingleColumn"))
                {
                    translator.PushYoozooUIYGUIListViewListLayoutType(L, Yoozoo.UI.YGUI.ListView.ListLayoutType.SingleColumn);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "SingleRow"))
                {
                    translator.PushYoozooUIYGUIListViewListLayoutType(L, Yoozoo.UI.YGUI.ListView.ListLayoutType.SingleRow);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "FlowHorizontal"))
                {
                    translator.PushYoozooUIYGUIListViewListLayoutType(L, Yoozoo.UI.YGUI.ListView.ListLayoutType.FlowHorizontal);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "FlowVertical"))
                {
                    translator.PushYoozooUIYGUIListViewListLayoutType(L, Yoozoo.UI.YGUI.ListView.ListLayoutType.FlowVertical);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Pagination"))
                {
                    translator.PushYoozooUIYGUIListViewListLayoutType(L, Yoozoo.UI.YGUI.ListView.ListLayoutType.Pagination);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for Yoozoo.UI.YGUI.ListView.ListLayoutType!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for Yoozoo.UI.YGUI.ListView.ListLayoutType! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class YoozooUIYGUIListViewVertAlignTypeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(Yoozoo.UI.YGUI.ListView.VertAlignType), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(Yoozoo.UI.YGUI.ListView.VertAlignType), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(Yoozoo.UI.YGUI.ListView.VertAlignType), L, null, 4, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Top", Yoozoo.UI.YGUI.ListView.VertAlignType.Top);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Middle", Yoozoo.UI.YGUI.ListView.VertAlignType.Middle);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Bottom", Yoozoo.UI.YGUI.ListView.VertAlignType.Bottom);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(Yoozoo.UI.YGUI.ListView.VertAlignType), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushYoozooUIYGUIListViewVertAlignType(L, (Yoozoo.UI.YGUI.ListView.VertAlignType)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Top"))
                {
                    translator.PushYoozooUIYGUIListViewVertAlignType(L, Yoozoo.UI.YGUI.ListView.VertAlignType.Top);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Middle"))
                {
                    translator.PushYoozooUIYGUIListViewVertAlignType(L, Yoozoo.UI.YGUI.ListView.VertAlignType.Middle);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Bottom"))
                {
                    translator.PushYoozooUIYGUIListViewVertAlignType(L, Yoozoo.UI.YGUI.ListView.VertAlignType.Bottom);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for Yoozoo.UI.YGUI.ListView.VertAlignType!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for Yoozoo.UI.YGUI.ListView.VertAlignType! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class YoozooUIYGUIListViewAlignTypeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(Yoozoo.UI.YGUI.ListView.AlignType), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(Yoozoo.UI.YGUI.ListView.AlignType), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(Yoozoo.UI.YGUI.ListView.AlignType), L, null, 4, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Left", Yoozoo.UI.YGUI.ListView.AlignType.Left);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Center", Yoozoo.UI.YGUI.ListView.AlignType.Center);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Right", Yoozoo.UI.YGUI.ListView.AlignType.Right);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(Yoozoo.UI.YGUI.ListView.AlignType), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushYoozooUIYGUIListViewAlignType(L, (Yoozoo.UI.YGUI.ListView.AlignType)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Left"))
                {
                    translator.PushYoozooUIYGUIListViewAlignType(L, Yoozoo.UI.YGUI.ListView.AlignType.Left);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Center"))
                {
                    translator.PushYoozooUIYGUIListViewAlignType(L, Yoozoo.UI.YGUI.ListView.AlignType.Center);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Right"))
                {
                    translator.PushYoozooUIYGUIListViewAlignType(L, Yoozoo.UI.YGUI.ListView.AlignType.Right);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for Yoozoo.UI.YGUI.ListView.AlignType!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for Yoozoo.UI.YGUI.ListView.AlignType! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class YoozooUIYGUIListViewChildrenRenderOrderWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(Yoozoo.UI.YGUI.ListView.ChildrenRenderOrder), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(Yoozoo.UI.YGUI.ListView.ChildrenRenderOrder), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(Yoozoo.UI.YGUI.ListView.ChildrenRenderOrder), L, null, 4, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Ascent", Yoozoo.UI.YGUI.ListView.ChildrenRenderOrder.Ascent);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Descent", Yoozoo.UI.YGUI.ListView.ChildrenRenderOrder.Descent);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Arch", Yoozoo.UI.YGUI.ListView.ChildrenRenderOrder.Arch);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(Yoozoo.UI.YGUI.ListView.ChildrenRenderOrder), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushYoozooUIYGUIListViewChildrenRenderOrder(L, (Yoozoo.UI.YGUI.ListView.ChildrenRenderOrder)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Ascent"))
                {
                    translator.PushYoozooUIYGUIListViewChildrenRenderOrder(L, Yoozoo.UI.YGUI.ListView.ChildrenRenderOrder.Ascent);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Descent"))
                {
                    translator.PushYoozooUIYGUIListViewChildrenRenderOrder(L, Yoozoo.UI.YGUI.ListView.ChildrenRenderOrder.Descent);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Arch"))
                {
                    translator.PushYoozooUIYGUIListViewChildrenRenderOrder(L, Yoozoo.UI.YGUI.ListView.ChildrenRenderOrder.Arch);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for Yoozoo.UI.YGUI.ListView.ChildrenRenderOrder!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for Yoozoo.UI.YGUI.ListView.ChildrenRenderOrder! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class YoozooModulesDownloadDownloadWhilePlayingManagerErrorWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(Yoozoo.Modules.Download.DownloadWhilePlayingManager.Error), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(Yoozoo.Modules.Download.DownloadWhilePlayingManager.Error), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(Yoozoo.Modules.Download.DownloadWhilePlayingManager.Error), L, null, 6, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "None", Yoozoo.Modules.Download.DownloadWhilePlayingManager.Error.None);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Unknown", Yoozoo.Modules.Download.DownloadWhilePlayingManager.Error.Unknown);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NotFound", Yoozoo.Modules.Download.DownloadWhilePlayingManager.Error.NotFound);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NetworkNotReachable", Yoozoo.Modules.Download.DownloadWhilePlayingManager.Error.NetworkNotReachable);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DiskFull", Yoozoo.Modules.Download.DownloadWhilePlayingManager.Error.DiskFull);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(Yoozoo.Modules.Download.DownloadWhilePlayingManager.Error), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushYoozooModulesDownloadDownloadWhilePlayingManagerError(L, (Yoozoo.Modules.Download.DownloadWhilePlayingManager.Error)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "None"))
                {
                    translator.PushYoozooModulesDownloadDownloadWhilePlayingManagerError(L, Yoozoo.Modules.Download.DownloadWhilePlayingManager.Error.None);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Unknown"))
                {
                    translator.PushYoozooModulesDownloadDownloadWhilePlayingManagerError(L, Yoozoo.Modules.Download.DownloadWhilePlayingManager.Error.Unknown);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "NotFound"))
                {
                    translator.PushYoozooModulesDownloadDownloadWhilePlayingManagerError(L, Yoozoo.Modules.Download.DownloadWhilePlayingManager.Error.NotFound);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "NetworkNotReachable"))
                {
                    translator.PushYoozooModulesDownloadDownloadWhilePlayingManagerError(L, Yoozoo.Modules.Download.DownloadWhilePlayingManager.Error.NetworkNotReachable);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "DiskFull"))
                {
                    translator.PushYoozooModulesDownloadDownloadWhilePlayingManagerError(L, Yoozoo.Modules.Download.DownloadWhilePlayingManager.Error.DiskFull);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for Yoozoo.Modules.Download.DownloadWhilePlayingManager.Error!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for Yoozoo.Modules.Download.DownloadWhilePlayingManager.Error! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class YoozooModulesDownloadPreDownloadManagerErrorWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(Yoozoo.Modules.Download.PreDownloadManager.Error), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(Yoozoo.Modules.Download.PreDownloadManager.Error), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(Yoozoo.Modules.Download.PreDownloadManager.Error), L, null, 5, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "None", Yoozoo.Modules.Download.PreDownloadManager.Error.None);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Unknown", Yoozoo.Modules.Download.PreDownloadManager.Error.Unknown);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NotFound", Yoozoo.Modules.Download.PreDownloadManager.Error.NotFound);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NetworkNotReachable", Yoozoo.Modules.Download.PreDownloadManager.Error.NetworkNotReachable);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(Yoozoo.Modules.Download.PreDownloadManager.Error), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushYoozooModulesDownloadPreDownloadManagerError(L, (Yoozoo.Modules.Download.PreDownloadManager.Error)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "None"))
                {
                    translator.PushYoozooModulesDownloadPreDownloadManagerError(L, Yoozoo.Modules.Download.PreDownloadManager.Error.None);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Unknown"))
                {
                    translator.PushYoozooModulesDownloadPreDownloadManagerError(L, Yoozoo.Modules.Download.PreDownloadManager.Error.Unknown);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "NotFound"))
                {
                    translator.PushYoozooModulesDownloadPreDownloadManagerError(L, Yoozoo.Modules.Download.PreDownloadManager.Error.NotFound);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "NetworkNotReachable"))
                {
                    translator.PushYoozooModulesDownloadPreDownloadManagerError(L, Yoozoo.Modules.Download.PreDownloadManager.Error.NetworkNotReachable);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for Yoozoo.Modules.Download.PreDownloadManager.Error!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for Yoozoo.Modules.Download.PreDownloadManager.Error! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class CinemachineCinemachineBrainUpdateMethodWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(Cinemachine.CinemachineBrain.UpdateMethod), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(Cinemachine.CinemachineBrain.UpdateMethod), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(Cinemachine.CinemachineBrain.UpdateMethod), L, null, 5, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FixedUpdate", Cinemachine.CinemachineBrain.UpdateMethod.FixedUpdate);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LateUpdate", Cinemachine.CinemachineBrain.UpdateMethod.LateUpdate);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SmartUpdate", Cinemachine.CinemachineBrain.UpdateMethod.SmartUpdate);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ManualUpdate", Cinemachine.CinemachineBrain.UpdateMethod.ManualUpdate);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(Cinemachine.CinemachineBrain.UpdateMethod), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushCinemachineCinemachineBrainUpdateMethod(L, (Cinemachine.CinemachineBrain.UpdateMethod)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "FixedUpdate"))
                {
                    translator.PushCinemachineCinemachineBrainUpdateMethod(L, Cinemachine.CinemachineBrain.UpdateMethod.FixedUpdate);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "LateUpdate"))
                {
                    translator.PushCinemachineCinemachineBrainUpdateMethod(L, Cinemachine.CinemachineBrain.UpdateMethod.LateUpdate);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "SmartUpdate"))
                {
                    translator.PushCinemachineCinemachineBrainUpdateMethod(L, Cinemachine.CinemachineBrain.UpdateMethod.SmartUpdate);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "ManualUpdate"))
                {
                    translator.PushCinemachineCinemachineBrainUpdateMethod(L, Cinemachine.CinemachineBrain.UpdateMethod.ManualUpdate);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for Cinemachine.CinemachineBrain.UpdateMethod!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for Cinemachine.CinemachineBrain.UpdateMethod! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class CinemachineCinemachineBrainBrainUpdateMethodWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(Cinemachine.CinemachineBrain.BrainUpdateMethod), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(Cinemachine.CinemachineBrain.BrainUpdateMethod), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(Cinemachine.CinemachineBrain.BrainUpdateMethod), L, null, 3, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FixedUpdate", Cinemachine.CinemachineBrain.BrainUpdateMethod.FixedUpdate);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LateUpdate", Cinemachine.CinemachineBrain.BrainUpdateMethod.LateUpdate);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(Cinemachine.CinemachineBrain.BrainUpdateMethod), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushCinemachineCinemachineBrainBrainUpdateMethod(L, (Cinemachine.CinemachineBrain.BrainUpdateMethod)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "FixedUpdate"))
                {
                    translator.PushCinemachineCinemachineBrainBrainUpdateMethod(L, Cinemachine.CinemachineBrain.BrainUpdateMethod.FixedUpdate);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "LateUpdate"))
                {
                    translator.PushCinemachineCinemachineBrainBrainUpdateMethod(L, Cinemachine.CinemachineBrain.BrainUpdateMethod.LateUpdate);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for Cinemachine.CinemachineBrain.BrainUpdateMethod!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for Cinemachine.CinemachineBrain.BrainUpdateMethod! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class CinemachineCinemachineBlendDefinitionStyleWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(Cinemachine.CinemachineBlendDefinition.Style), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(Cinemachine.CinemachineBlendDefinition.Style), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(Cinemachine.CinemachineBlendDefinition.Style), L, null, 9, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Cut", Cinemachine.CinemachineBlendDefinition.Style.Cut);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "EaseInOut", Cinemachine.CinemachineBlendDefinition.Style.EaseInOut);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "EaseIn", Cinemachine.CinemachineBlendDefinition.Style.EaseIn);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "EaseOut", Cinemachine.CinemachineBlendDefinition.Style.EaseOut);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "HardIn", Cinemachine.CinemachineBlendDefinition.Style.HardIn);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "HardOut", Cinemachine.CinemachineBlendDefinition.Style.HardOut);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Linear", Cinemachine.CinemachineBlendDefinition.Style.Linear);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Custom", Cinemachine.CinemachineBlendDefinition.Style.Custom);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(Cinemachine.CinemachineBlendDefinition.Style), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushCinemachineCinemachineBlendDefinitionStyle(L, (Cinemachine.CinemachineBlendDefinition.Style)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Cut"))
                {
                    translator.PushCinemachineCinemachineBlendDefinitionStyle(L, Cinemachine.CinemachineBlendDefinition.Style.Cut);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "EaseInOut"))
                {
                    translator.PushCinemachineCinemachineBlendDefinitionStyle(L, Cinemachine.CinemachineBlendDefinition.Style.EaseInOut);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "EaseIn"))
                {
                    translator.PushCinemachineCinemachineBlendDefinitionStyle(L, Cinemachine.CinemachineBlendDefinition.Style.EaseIn);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "EaseOut"))
                {
                    translator.PushCinemachineCinemachineBlendDefinitionStyle(L, Cinemachine.CinemachineBlendDefinition.Style.EaseOut);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "HardIn"))
                {
                    translator.PushCinemachineCinemachineBlendDefinitionStyle(L, Cinemachine.CinemachineBlendDefinition.Style.HardIn);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "HardOut"))
                {
                    translator.PushCinemachineCinemachineBlendDefinitionStyle(L, Cinemachine.CinemachineBlendDefinition.Style.HardOut);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Linear"))
                {
                    translator.PushCinemachineCinemachineBlendDefinitionStyle(L, Cinemachine.CinemachineBlendDefinition.Style.Linear);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Custom"))
                {
                    translator.PushCinemachineCinemachineBlendDefinitionStyle(L, Cinemachine.CinemachineBlendDefinition.Style.Custom);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for Cinemachine.CinemachineBlendDefinition.Style!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for Cinemachine.CinemachineBlendDefinition.Style! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class CinemachineCinemachineTransposerBindingModeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(Cinemachine.CinemachineTransposer.BindingMode), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(Cinemachine.CinemachineTransposer.BindingMode), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(Cinemachine.CinemachineTransposer.BindingMode), L, null, 7, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LockToTargetOnAssign", Cinemachine.CinemachineTransposer.BindingMode.LockToTargetOnAssign);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LockToTargetWithWorldUp", Cinemachine.CinemachineTransposer.BindingMode.LockToTargetWithWorldUp);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LockToTargetNoRoll", Cinemachine.CinemachineTransposer.BindingMode.LockToTargetNoRoll);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LockToTarget", Cinemachine.CinemachineTransposer.BindingMode.LockToTarget);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "WorldSpace", Cinemachine.CinemachineTransposer.BindingMode.WorldSpace);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SimpleFollowWithWorldUp", Cinemachine.CinemachineTransposer.BindingMode.SimpleFollowWithWorldUp);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(Cinemachine.CinemachineTransposer.BindingMode), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushCinemachineCinemachineTransposerBindingMode(L, (Cinemachine.CinemachineTransposer.BindingMode)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "LockToTargetOnAssign"))
                {
                    translator.PushCinemachineCinemachineTransposerBindingMode(L, Cinemachine.CinemachineTransposer.BindingMode.LockToTargetOnAssign);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "LockToTargetWithWorldUp"))
                {
                    translator.PushCinemachineCinemachineTransposerBindingMode(L, Cinemachine.CinemachineTransposer.BindingMode.LockToTargetWithWorldUp);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "LockToTargetNoRoll"))
                {
                    translator.PushCinemachineCinemachineTransposerBindingMode(L, Cinemachine.CinemachineTransposer.BindingMode.LockToTargetNoRoll);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "LockToTarget"))
                {
                    translator.PushCinemachineCinemachineTransposerBindingMode(L, Cinemachine.CinemachineTransposer.BindingMode.LockToTarget);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "WorldSpace"))
                {
                    translator.PushCinemachineCinemachineTransposerBindingMode(L, Cinemachine.CinemachineTransposer.BindingMode.WorldSpace);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "SimpleFollowWithWorldUp"))
                {
                    translator.PushCinemachineCinemachineTransposerBindingMode(L, Cinemachine.CinemachineTransposer.BindingMode.SimpleFollowWithWorldUp);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for Cinemachine.CinemachineTransposer.BindingMode!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for Cinemachine.CinemachineTransposer.BindingMode! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class CinemachineCinemachineTransposerAngularDampingModeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(Cinemachine.CinemachineTransposer.AngularDampingMode), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(Cinemachine.CinemachineTransposer.AngularDampingMode), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(Cinemachine.CinemachineTransposer.AngularDampingMode), L, null, 3, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Euler", Cinemachine.CinemachineTransposer.AngularDampingMode.Euler);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Quaternion", Cinemachine.CinemachineTransposer.AngularDampingMode.Quaternion);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(Cinemachine.CinemachineTransposer.AngularDampingMode), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushCinemachineCinemachineTransposerAngularDampingMode(L, (Cinemachine.CinemachineTransposer.AngularDampingMode)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Euler"))
                {
                    translator.PushCinemachineCinemachineTransposerAngularDampingMode(L, Cinemachine.CinemachineTransposer.AngularDampingMode.Euler);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Quaternion"))
                {
                    translator.PushCinemachineCinemachineTransposerAngularDampingMode(L, Cinemachine.CinemachineTransposer.AngularDampingMode.Quaternion);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for Cinemachine.CinemachineTransposer.AngularDampingMode!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for Cinemachine.CinemachineTransposer.AngularDampingMode! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class Reporter_LogTypeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(Reporter._LogType), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(Reporter._LogType), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(Reporter._LogType), L, null, 6, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Assert", Reporter._LogType.Assert);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Error", Reporter._LogType.Error);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Exception", Reporter._LogType.Exception);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Log", Reporter._LogType.Log);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Warning", Reporter._LogType.Warning);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(Reporter._LogType), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushReporter_LogType(L, (Reporter._LogType)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Assert"))
                {
                    translator.PushReporter_LogType(L, Reporter._LogType.Assert);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Error"))
                {
                    translator.PushReporter_LogType(L, Reporter._LogType.Error);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Exception"))
                {
                    translator.PushReporter_LogType(L, Reporter._LogType.Exception);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Log"))
                {
                    translator.PushReporter_LogType(L, Reporter._LogType.Log);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Warning"))
                {
                    translator.PushReporter_LogType(L, Reporter._LogType.Warning);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for Reporter._LogType!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for Reporter._LogType! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class SystemReflectionBindingFlagsWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(System.Reflection.BindingFlags), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(System.Reflection.BindingFlags), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(System.Reflection.BindingFlags), L, null, 22, 0, 0);

            Utils.RegisterEnumType(L, typeof(System.Reflection.BindingFlags));

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(System.Reflection.BindingFlags), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushSystemReflectionBindingFlags(L, (System.Reflection.BindingFlags)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

                try
				{
                    translator.TranslateToEnumToTop(L, typeof(System.Reflection.BindingFlags), 1);
				}
				catch (System.Exception e)
				{
					return LuaAPI.luaL_error(L, "cast to " + typeof(System.Reflection.BindingFlags) + " exception:" + e);
				}

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for System.Reflection.BindingFlags! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class ReddotNodeReddotNodeTypeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(ReddotNode.ReddotNodeType), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(ReddotNode.ReddotNodeType), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(ReddotNode.ReddotNodeType), L, null, 2, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NONE", ReddotNode.ReddotNodeType.NONE);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(ReddotNode.ReddotNodeType), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushReddotNodeReddotNodeType(L, (ReddotNode.ReddotNodeType)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "NONE"))
                {
                    translator.PushReddotNodeReddotNodeType(L, ReddotNode.ReddotNodeType.NONE);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for ReddotNode.ReddotNodeType!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for ReddotNode.ReddotNodeType! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineUIGraphicRaycasterBlockingObjectsWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.UI.GraphicRaycaster.BlockingObjects), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.UI.GraphicRaycaster.BlockingObjects), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.UI.GraphicRaycaster.BlockingObjects), L, null, 5, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "None", UnityEngine.UI.GraphicRaycaster.BlockingObjects.None);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "TwoD", UnityEngine.UI.GraphicRaycaster.BlockingObjects.TwoD);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ThreeD", UnityEngine.UI.GraphicRaycaster.BlockingObjects.ThreeD);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "All", UnityEngine.UI.GraphicRaycaster.BlockingObjects.All);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.UI.GraphicRaycaster.BlockingObjects), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineUIGraphicRaycasterBlockingObjects(L, (UnityEngine.UI.GraphicRaycaster.BlockingObjects)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "None"))
                {
                    translator.PushUnityEngineUIGraphicRaycasterBlockingObjects(L, UnityEngine.UI.GraphicRaycaster.BlockingObjects.None);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "TwoD"))
                {
                    translator.PushUnityEngineUIGraphicRaycasterBlockingObjects(L, UnityEngine.UI.GraphicRaycaster.BlockingObjects.TwoD);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "ThreeD"))
                {
                    translator.PushUnityEngineUIGraphicRaycasterBlockingObjects(L, UnityEngine.UI.GraphicRaycaster.BlockingObjects.ThreeD);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "All"))
                {
                    translator.PushUnityEngineUIGraphicRaycasterBlockingObjects(L, UnityEngine.UI.GraphicRaycaster.BlockingObjects.All);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.UI.GraphicRaycaster.BlockingObjects!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.UI.GraphicRaycaster.BlockingObjects! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineUICanvasScalerScaleModeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.UI.CanvasScaler.ScaleMode), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.UI.CanvasScaler.ScaleMode), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.UI.CanvasScaler.ScaleMode), L, null, 4, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ConstantPixelSize", UnityEngine.UI.CanvasScaler.ScaleMode.ConstantPixelSize);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ScaleWithScreenSize", UnityEngine.UI.CanvasScaler.ScaleMode.ScaleWithScreenSize);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ConstantPhysicalSize", UnityEngine.UI.CanvasScaler.ScaleMode.ConstantPhysicalSize);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.UI.CanvasScaler.ScaleMode), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineUICanvasScalerScaleMode(L, (UnityEngine.UI.CanvasScaler.ScaleMode)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "ConstantPixelSize"))
                {
                    translator.PushUnityEngineUICanvasScalerScaleMode(L, UnityEngine.UI.CanvasScaler.ScaleMode.ConstantPixelSize);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "ScaleWithScreenSize"))
                {
                    translator.PushUnityEngineUICanvasScalerScaleMode(L, UnityEngine.UI.CanvasScaler.ScaleMode.ScaleWithScreenSize);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "ConstantPhysicalSize"))
                {
                    translator.PushUnityEngineUICanvasScalerScaleMode(L, UnityEngine.UI.CanvasScaler.ScaleMode.ConstantPhysicalSize);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.UI.CanvasScaler.ScaleMode!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.UI.CanvasScaler.ScaleMode! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineUICanvasScalerScreenMatchModeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.UI.CanvasScaler.ScreenMatchMode), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.UI.CanvasScaler.ScreenMatchMode), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.UI.CanvasScaler.ScreenMatchMode), L, null, 4, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MatchWidthOrHeight", UnityEngine.UI.CanvasScaler.ScreenMatchMode.MatchWidthOrHeight);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Expand", UnityEngine.UI.CanvasScaler.ScreenMatchMode.Expand);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Shrink", UnityEngine.UI.CanvasScaler.ScreenMatchMode.Shrink);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.UI.CanvasScaler.ScreenMatchMode), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineUICanvasScalerScreenMatchMode(L, (UnityEngine.UI.CanvasScaler.ScreenMatchMode)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "MatchWidthOrHeight"))
                {
                    translator.PushUnityEngineUICanvasScalerScreenMatchMode(L, UnityEngine.UI.CanvasScaler.ScreenMatchMode.MatchWidthOrHeight);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Expand"))
                {
                    translator.PushUnityEngineUICanvasScalerScreenMatchMode(L, UnityEngine.UI.CanvasScaler.ScreenMatchMode.Expand);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Shrink"))
                {
                    translator.PushUnityEngineUICanvasScalerScreenMatchMode(L, UnityEngine.UI.CanvasScaler.ScreenMatchMode.Shrink);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.UI.CanvasScaler.ScreenMatchMode!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.UI.CanvasScaler.ScreenMatchMode! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineUICanvasScalerUnitWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.UI.CanvasScaler.Unit), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.UI.CanvasScaler.Unit), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.UI.CanvasScaler.Unit), L, null, 6, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Centimeters", UnityEngine.UI.CanvasScaler.Unit.Centimeters);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Millimeters", UnityEngine.UI.CanvasScaler.Unit.Millimeters);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Inches", UnityEngine.UI.CanvasScaler.Unit.Inches);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Points", UnityEngine.UI.CanvasScaler.Unit.Points);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Picas", UnityEngine.UI.CanvasScaler.Unit.Picas);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.UI.CanvasScaler.Unit), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineUICanvasScalerUnit(L, (UnityEngine.UI.CanvasScaler.Unit)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Centimeters"))
                {
                    translator.PushUnityEngineUICanvasScalerUnit(L, UnityEngine.UI.CanvasScaler.Unit.Centimeters);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Millimeters"))
                {
                    translator.PushUnityEngineUICanvasScalerUnit(L, UnityEngine.UI.CanvasScaler.Unit.Millimeters);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Inches"))
                {
                    translator.PushUnityEngineUICanvasScalerUnit(L, UnityEngine.UI.CanvasScaler.Unit.Inches);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Points"))
                {
                    translator.PushUnityEngineUICanvasScalerUnit(L, UnityEngine.UI.CanvasScaler.Unit.Points);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Picas"))
                {
                    translator.PushUnityEngineUICanvasScalerUnit(L, UnityEngine.UI.CanvasScaler.Unit.Picas);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.UI.CanvasScaler.Unit!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.UI.CanvasScaler.Unit! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineUIImageTypeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.UI.Image.Type), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.UI.Image.Type), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.UI.Image.Type), L, null, 5, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Simple", UnityEngine.UI.Image.Type.Simple);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Sliced", UnityEngine.UI.Image.Type.Sliced);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Tiled", UnityEngine.UI.Image.Type.Tiled);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Filled", UnityEngine.UI.Image.Type.Filled);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.UI.Image.Type), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineUIImageType(L, (UnityEngine.UI.Image.Type)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Simple"))
                {
                    translator.PushUnityEngineUIImageType(L, UnityEngine.UI.Image.Type.Simple);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Sliced"))
                {
                    translator.PushUnityEngineUIImageType(L, UnityEngine.UI.Image.Type.Sliced);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Tiled"))
                {
                    translator.PushUnityEngineUIImageType(L, UnityEngine.UI.Image.Type.Tiled);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Filled"))
                {
                    translator.PushUnityEngineUIImageType(L, UnityEngine.UI.Image.Type.Filled);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.UI.Image.Type!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.UI.Image.Type! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineUIImageFillMethodWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.UI.Image.FillMethod), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.UI.Image.FillMethod), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.UI.Image.FillMethod), L, null, 6, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Horizontal", UnityEngine.UI.Image.FillMethod.Horizontal);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Vertical", UnityEngine.UI.Image.FillMethod.Vertical);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Radial90", UnityEngine.UI.Image.FillMethod.Radial90);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Radial180", UnityEngine.UI.Image.FillMethod.Radial180);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Radial360", UnityEngine.UI.Image.FillMethod.Radial360);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.UI.Image.FillMethod), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineUIImageFillMethod(L, (UnityEngine.UI.Image.FillMethod)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Horizontal"))
                {
                    translator.PushUnityEngineUIImageFillMethod(L, UnityEngine.UI.Image.FillMethod.Horizontal);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Vertical"))
                {
                    translator.PushUnityEngineUIImageFillMethod(L, UnityEngine.UI.Image.FillMethod.Vertical);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Radial90"))
                {
                    translator.PushUnityEngineUIImageFillMethod(L, UnityEngine.UI.Image.FillMethod.Radial90);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Radial180"))
                {
                    translator.PushUnityEngineUIImageFillMethod(L, UnityEngine.UI.Image.FillMethod.Radial180);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Radial360"))
                {
                    translator.PushUnityEngineUIImageFillMethod(L, UnityEngine.UI.Image.FillMethod.Radial360);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.UI.Image.FillMethod!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.UI.Image.FillMethod! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineUIImageOriginHorizontalWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.UI.Image.OriginHorizontal), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.UI.Image.OriginHorizontal), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.UI.Image.OriginHorizontal), L, null, 3, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Left", UnityEngine.UI.Image.OriginHorizontal.Left);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Right", UnityEngine.UI.Image.OriginHorizontal.Right);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.UI.Image.OriginHorizontal), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineUIImageOriginHorizontal(L, (UnityEngine.UI.Image.OriginHorizontal)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Left"))
                {
                    translator.PushUnityEngineUIImageOriginHorizontal(L, UnityEngine.UI.Image.OriginHorizontal.Left);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Right"))
                {
                    translator.PushUnityEngineUIImageOriginHorizontal(L, UnityEngine.UI.Image.OriginHorizontal.Right);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.UI.Image.OriginHorizontal!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.UI.Image.OriginHorizontal! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineUIImageOriginVerticalWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.UI.Image.OriginVertical), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.UI.Image.OriginVertical), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.UI.Image.OriginVertical), L, null, 3, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Bottom", UnityEngine.UI.Image.OriginVertical.Bottom);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Top", UnityEngine.UI.Image.OriginVertical.Top);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.UI.Image.OriginVertical), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineUIImageOriginVertical(L, (UnityEngine.UI.Image.OriginVertical)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Bottom"))
                {
                    translator.PushUnityEngineUIImageOriginVertical(L, UnityEngine.UI.Image.OriginVertical.Bottom);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Top"))
                {
                    translator.PushUnityEngineUIImageOriginVertical(L, UnityEngine.UI.Image.OriginVertical.Top);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.UI.Image.OriginVertical!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.UI.Image.OriginVertical! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineUIImageOrigin90Wrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.UI.Image.Origin90), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.UI.Image.Origin90), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.UI.Image.Origin90), L, null, 5, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BottomLeft", UnityEngine.UI.Image.Origin90.BottomLeft);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "TopLeft", UnityEngine.UI.Image.Origin90.TopLeft);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "TopRight", UnityEngine.UI.Image.Origin90.TopRight);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BottomRight", UnityEngine.UI.Image.Origin90.BottomRight);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.UI.Image.Origin90), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineUIImageOrigin90(L, (UnityEngine.UI.Image.Origin90)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "BottomLeft"))
                {
                    translator.PushUnityEngineUIImageOrigin90(L, UnityEngine.UI.Image.Origin90.BottomLeft);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "TopLeft"))
                {
                    translator.PushUnityEngineUIImageOrigin90(L, UnityEngine.UI.Image.Origin90.TopLeft);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "TopRight"))
                {
                    translator.PushUnityEngineUIImageOrigin90(L, UnityEngine.UI.Image.Origin90.TopRight);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "BottomRight"))
                {
                    translator.PushUnityEngineUIImageOrigin90(L, UnityEngine.UI.Image.Origin90.BottomRight);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.UI.Image.Origin90!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.UI.Image.Origin90! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineUIImageOrigin180Wrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.UI.Image.Origin180), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.UI.Image.Origin180), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.UI.Image.Origin180), L, null, 5, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Bottom", UnityEngine.UI.Image.Origin180.Bottom);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Left", UnityEngine.UI.Image.Origin180.Left);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Top", UnityEngine.UI.Image.Origin180.Top);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Right", UnityEngine.UI.Image.Origin180.Right);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.UI.Image.Origin180), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineUIImageOrigin180(L, (UnityEngine.UI.Image.Origin180)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Bottom"))
                {
                    translator.PushUnityEngineUIImageOrigin180(L, UnityEngine.UI.Image.Origin180.Bottom);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Left"))
                {
                    translator.PushUnityEngineUIImageOrigin180(L, UnityEngine.UI.Image.Origin180.Left);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Top"))
                {
                    translator.PushUnityEngineUIImageOrigin180(L, UnityEngine.UI.Image.Origin180.Top);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Right"))
                {
                    translator.PushUnityEngineUIImageOrigin180(L, UnityEngine.UI.Image.Origin180.Right);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.UI.Image.Origin180!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.UI.Image.Origin180! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineUIImageOrigin360Wrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.UI.Image.Origin360), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.UI.Image.Origin360), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.UI.Image.Origin360), L, null, 5, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Bottom", UnityEngine.UI.Image.Origin360.Bottom);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Right", UnityEngine.UI.Image.Origin360.Right);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Top", UnityEngine.UI.Image.Origin360.Top);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Left", UnityEngine.UI.Image.Origin360.Left);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.UI.Image.Origin360), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineUIImageOrigin360(L, (UnityEngine.UI.Image.Origin360)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Bottom"))
                {
                    translator.PushUnityEngineUIImageOrigin360(L, UnityEngine.UI.Image.Origin360.Bottom);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Right"))
                {
                    translator.PushUnityEngineUIImageOrigin360(L, UnityEngine.UI.Image.Origin360.Right);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Top"))
                {
                    translator.PushUnityEngineUIImageOrigin360(L, UnityEngine.UI.Image.Origin360.Top);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Left"))
                {
                    translator.PushUnityEngineUIImageOrigin360(L, UnityEngine.UI.Image.Origin360.Left);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.UI.Image.Origin360!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.UI.Image.Origin360! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class YoozooUIYGUIYScrollRectDirectionWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(Yoozoo.UI.YGUI.YScrollRect.Direction), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(Yoozoo.UI.YGUI.YScrollRect.Direction), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(Yoozoo.UI.YGUI.YScrollRect.Direction), L, null, 3, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Horizontal", Yoozoo.UI.YGUI.YScrollRect.Direction.Horizontal);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Vertical", Yoozoo.UI.YGUI.YScrollRect.Direction.Vertical);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(Yoozoo.UI.YGUI.YScrollRect.Direction), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushYoozooUIYGUIYScrollRectDirection(L, (Yoozoo.UI.YGUI.YScrollRect.Direction)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Horizontal"))
                {
                    translator.PushYoozooUIYGUIYScrollRectDirection(L, Yoozoo.UI.YGUI.YScrollRect.Direction.Horizontal);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Vertical"))
                {
                    translator.PushYoozooUIYGUIYScrollRectDirection(L, Yoozoo.UI.YGUI.YScrollRect.Direction.Vertical);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for Yoozoo.UI.YGUI.YScrollRect.Direction!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for Yoozoo.UI.YGUI.YScrollRect.Direction! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class YoozooUIYGUIYScrollRectMovementTypeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(Yoozoo.UI.YGUI.YScrollRect.MovementType), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(Yoozoo.UI.YGUI.YScrollRect.MovementType), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(Yoozoo.UI.YGUI.YScrollRect.MovementType), L, null, 4, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Unrestricted", Yoozoo.UI.YGUI.YScrollRect.MovementType.Unrestricted);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Elastic", Yoozoo.UI.YGUI.YScrollRect.MovementType.Elastic);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Clamped", Yoozoo.UI.YGUI.YScrollRect.MovementType.Clamped);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(Yoozoo.UI.YGUI.YScrollRect.MovementType), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushYoozooUIYGUIYScrollRectMovementType(L, (Yoozoo.UI.YGUI.YScrollRect.MovementType)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Unrestricted"))
                {
                    translator.PushYoozooUIYGUIYScrollRectMovementType(L, Yoozoo.UI.YGUI.YScrollRect.MovementType.Unrestricted);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Elastic"))
                {
                    translator.PushYoozooUIYGUIYScrollRectMovementType(L, Yoozoo.UI.YGUI.YScrollRect.MovementType.Elastic);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Clamped"))
                {
                    translator.PushYoozooUIYGUIYScrollRectMovementType(L, Yoozoo.UI.YGUI.YScrollRect.MovementType.Clamped);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for Yoozoo.UI.YGUI.YScrollRect.MovementType!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for Yoozoo.UI.YGUI.YScrollRect.MovementType! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class YoozooUIYGUIYScrollRectScrollbarVisibilityWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(Yoozoo.UI.YGUI.YScrollRect.ScrollbarVisibility), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(Yoozoo.UI.YGUI.YScrollRect.ScrollbarVisibility), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(Yoozoo.UI.YGUI.YScrollRect.ScrollbarVisibility), L, null, 3, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Permanent", Yoozoo.UI.YGUI.YScrollRect.ScrollbarVisibility.Permanent);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AutoHide", Yoozoo.UI.YGUI.YScrollRect.ScrollbarVisibility.AutoHide);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(Yoozoo.UI.YGUI.YScrollRect.ScrollbarVisibility), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushYoozooUIYGUIYScrollRectScrollbarVisibility(L, (Yoozoo.UI.YGUI.YScrollRect.ScrollbarVisibility)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Permanent"))
                {
                    translator.PushYoozooUIYGUIYScrollRectScrollbarVisibility(L, Yoozoo.UI.YGUI.YScrollRect.ScrollbarVisibility.Permanent);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "AutoHide"))
                {
                    translator.PushYoozooUIYGUIYScrollRectScrollbarVisibility(L, Yoozoo.UI.YGUI.YScrollRect.ScrollbarVisibility.AutoHide);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for Yoozoo.UI.YGUI.YScrollRect.ScrollbarVisibility!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for Yoozoo.UI.YGUI.YScrollRect.ScrollbarVisibility! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineUISelectableTransitionWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.UI.Selectable.Transition), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.UI.Selectable.Transition), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.UI.Selectable.Transition), L, null, 5, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "None", UnityEngine.UI.Selectable.Transition.None);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ColorTint", UnityEngine.UI.Selectable.Transition.ColorTint);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SpriteSwap", UnityEngine.UI.Selectable.Transition.SpriteSwap);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Animation", UnityEngine.UI.Selectable.Transition.Animation);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.UI.Selectable.Transition), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineUISelectableTransition(L, (UnityEngine.UI.Selectable.Transition)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "None"))
                {
                    translator.PushUnityEngineUISelectableTransition(L, UnityEngine.UI.Selectable.Transition.None);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "ColorTint"))
                {
                    translator.PushUnityEngineUISelectableTransition(L, UnityEngine.UI.Selectable.Transition.ColorTint);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "SpriteSwap"))
                {
                    translator.PushUnityEngineUISelectableTransition(L, UnityEngine.UI.Selectable.Transition.SpriteSwap);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Animation"))
                {
                    translator.PushUnityEngineUISelectableTransition(L, UnityEngine.UI.Selectable.Transition.Animation);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.UI.Selectable.Transition!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.UI.Selectable.Transition! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class MopsicusPluginsMobileInputFieldReturnKeyTypeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(Mopsicus.Plugins.MobileInputField.ReturnKeyType), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(Mopsicus.Plugins.MobileInputField.ReturnKeyType), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(Mopsicus.Plugins.MobileInputField.ReturnKeyType), L, null, 6, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Default", Mopsicus.Plugins.MobileInputField.ReturnKeyType.Default);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Next", Mopsicus.Plugins.MobileInputField.ReturnKeyType.Next);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Done", Mopsicus.Plugins.MobileInputField.ReturnKeyType.Done);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Search", Mopsicus.Plugins.MobileInputField.ReturnKeyType.Search);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Send", Mopsicus.Plugins.MobileInputField.ReturnKeyType.Send);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(Mopsicus.Plugins.MobileInputField.ReturnKeyType), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushMopsicusPluginsMobileInputFieldReturnKeyType(L, (Mopsicus.Plugins.MobileInputField.ReturnKeyType)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Default"))
                {
                    translator.PushMopsicusPluginsMobileInputFieldReturnKeyType(L, Mopsicus.Plugins.MobileInputField.ReturnKeyType.Default);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Next"))
                {
                    translator.PushMopsicusPluginsMobileInputFieldReturnKeyType(L, Mopsicus.Plugins.MobileInputField.ReturnKeyType.Next);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Done"))
                {
                    translator.PushMopsicusPluginsMobileInputFieldReturnKeyType(L, Mopsicus.Plugins.MobileInputField.ReturnKeyType.Done);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Search"))
                {
                    translator.PushMopsicusPluginsMobileInputFieldReturnKeyType(L, Mopsicus.Plugins.MobileInputField.ReturnKeyType.Search);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Send"))
                {
                    translator.PushMopsicusPluginsMobileInputFieldReturnKeyType(L, Mopsicus.Plugins.MobileInputField.ReturnKeyType.Send);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for Mopsicus.Plugins.MobileInputField.ReturnKeyType!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for Mopsicus.Plugins.MobileInputField.ReturnKeyType! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class CinemachineCinemachineVirtualCameraBaseStandbyUpdateModeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(Cinemachine.CinemachineVirtualCameraBase.StandbyUpdateMode), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(Cinemachine.CinemachineVirtualCameraBase.StandbyUpdateMode), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(Cinemachine.CinemachineVirtualCameraBase.StandbyUpdateMode), L, null, 4, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Never", Cinemachine.CinemachineVirtualCameraBase.StandbyUpdateMode.Never);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Always", Cinemachine.CinemachineVirtualCameraBase.StandbyUpdateMode.Always);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RoundRobin", Cinemachine.CinemachineVirtualCameraBase.StandbyUpdateMode.RoundRobin);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(Cinemachine.CinemachineVirtualCameraBase.StandbyUpdateMode), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushCinemachineCinemachineVirtualCameraBaseStandbyUpdateMode(L, (Cinemachine.CinemachineVirtualCameraBase.StandbyUpdateMode)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Never"))
                {
                    translator.PushCinemachineCinemachineVirtualCameraBaseStandbyUpdateMode(L, Cinemachine.CinemachineVirtualCameraBase.StandbyUpdateMode.Never);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Always"))
                {
                    translator.PushCinemachineCinemachineVirtualCameraBaseStandbyUpdateMode(L, Cinemachine.CinemachineVirtualCameraBase.StandbyUpdateMode.Always);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "RoundRobin"))
                {
                    translator.PushCinemachineCinemachineVirtualCameraBaseStandbyUpdateMode(L, Cinemachine.CinemachineVirtualCameraBase.StandbyUpdateMode.RoundRobin);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for Cinemachine.CinemachineVirtualCameraBase.StandbyUpdateMode!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for Cinemachine.CinemachineVirtualCameraBase.StandbyUpdateMode! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class CinemachineCinemachineVirtualCameraBaseBlendHintWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(Cinemachine.CinemachineVirtualCameraBase.BlendHint), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(Cinemachine.CinemachineVirtualCameraBase.BlendHint), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(Cinemachine.CinemachineVirtualCameraBase.BlendHint), L, null, 5, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "None", Cinemachine.CinemachineVirtualCameraBase.BlendHint.None);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SphericalPosition", Cinemachine.CinemachineVirtualCameraBase.BlendHint.SphericalPosition);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CylindricalPosition", Cinemachine.CinemachineVirtualCameraBase.BlendHint.CylindricalPosition);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ScreenSpaceAimWhenTargetsDiffer", Cinemachine.CinemachineVirtualCameraBase.BlendHint.ScreenSpaceAimWhenTargetsDiffer);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(Cinemachine.CinemachineVirtualCameraBase.BlendHint), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushCinemachineCinemachineVirtualCameraBaseBlendHint(L, (Cinemachine.CinemachineVirtualCameraBase.BlendHint)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "None"))
                {
                    translator.PushCinemachineCinemachineVirtualCameraBaseBlendHint(L, Cinemachine.CinemachineVirtualCameraBase.BlendHint.None);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "SphericalPosition"))
                {
                    translator.PushCinemachineCinemachineVirtualCameraBaseBlendHint(L, Cinemachine.CinemachineVirtualCameraBase.BlendHint.SphericalPosition);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "CylindricalPosition"))
                {
                    translator.PushCinemachineCinemachineVirtualCameraBaseBlendHint(L, Cinemachine.CinemachineVirtualCameraBase.BlendHint.CylindricalPosition);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "ScreenSpaceAimWhenTargetsDiffer"))
                {
                    translator.PushCinemachineCinemachineVirtualCameraBaseBlendHint(L, Cinemachine.CinemachineVirtualCameraBase.BlendHint.ScreenSpaceAimWhenTargetsDiffer);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for Cinemachine.CinemachineVirtualCameraBase.BlendHint!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for Cinemachine.CinemachineVirtualCameraBase.BlendHint! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class MarchEntitySquareActionWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(MarchEntity.SquareAction), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(MarchEntity.SquareAction), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(MarchEntity.SquareAction), L, null, 4, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Stay", MarchEntity.SquareAction.Stay);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "March", MarchEntity.SquareAction.March);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Attack", MarchEntity.SquareAction.Attack);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(MarchEntity.SquareAction), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushMarchEntitySquareAction(L, (MarchEntity.SquareAction)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Stay"))
                {
                    translator.PushMarchEntitySquareAction(L, MarchEntity.SquareAction.Stay);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "March"))
                {
                    translator.PushMarchEntitySquareAction(L, MarchEntity.SquareAction.March);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Attack"))
                {
                    translator.PushMarchEntitySquareAction(L, MarchEntity.SquareAction.Attack);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for MarchEntity.SquareAction!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for MarchEntity.SquareAction! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class comyouzuwarhprotocolNormalAttackTypeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(com.youzu.warh.protocol.NormalAttackType), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(com.youzu.warh.protocol.NormalAttackType), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(com.youzu.warh.protocol.NormalAttackType), L, null, 4, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NORMAL_ATTACK_1", com.youzu.warh.protocol.NormalAttackType.NORMAL_ATTACK_1);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "COUNTER_ATTACK_2", com.youzu.warh.protocol.NormalAttackType.COUNTER_ATTACK_2);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SIEGE_ATTACK_3", com.youzu.warh.protocol.NormalAttackType.SIEGE_ATTACK_3);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(com.youzu.warh.protocol.NormalAttackType), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushcomyouzuwarhprotocolNormalAttackType(L, (com.youzu.warh.protocol.NormalAttackType)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "NORMAL_ATTACK_1"))
                {
                    translator.PushcomyouzuwarhprotocolNormalAttackType(L, com.youzu.warh.protocol.NormalAttackType.NORMAL_ATTACK_1);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "COUNTER_ATTACK_2"))
                {
                    translator.PushcomyouzuwarhprotocolNormalAttackType(L, com.youzu.warh.protocol.NormalAttackType.COUNTER_ATTACK_2);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "SIEGE_ATTACK_3"))
                {
                    translator.PushcomyouzuwarhprotocolNormalAttackType(L, com.youzu.warh.protocol.NormalAttackType.SIEGE_ATTACK_3);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for com.youzu.warh.protocol.NormalAttackType!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for com.youzu.warh.protocol.NormalAttackType! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class comyouzuwarhprotocolBattleMountUnitTypeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(com.youzu.warh.protocol.BattleMountUnitType), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(com.youzu.warh.protocol.BattleMountUnitType), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(com.youzu.warh.protocol.BattleMountUnitType), L, null, 2, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BUILDING_SIEGE", com.youzu.warh.protocol.BattleMountUnitType.BUILDING_SIEGE);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(com.youzu.warh.protocol.BattleMountUnitType), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushcomyouzuwarhprotocolBattleMountUnitType(L, (com.youzu.warh.protocol.BattleMountUnitType)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "BUILDING_SIEGE"))
                {
                    translator.PushcomyouzuwarhprotocolBattleMountUnitType(L, com.youzu.warh.protocol.BattleMountUnitType.BUILDING_SIEGE);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for com.youzu.warh.protocol.BattleMountUnitType!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for com.youzu.warh.protocol.BattleMountUnitType! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class comyouzuwarhprotocolResourceWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(com.youzu.warh.protocol.Resource), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(com.youzu.warh.protocol.Resource), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(com.youzu.warh.protocol.Resource), L, null, 39, 0, 0);

            Utils.RegisterEnumType(L, typeof(com.youzu.warh.protocol.Resource));

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(com.youzu.warh.protocol.Resource), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushcomyouzuwarhprotocolResource(L, (com.youzu.warh.protocol.Resource)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

                try
				{
                    translator.TranslateToEnumToTop(L, typeof(com.youzu.warh.protocol.Resource), 1);
				}
				catch (System.Exception e)
				{
					return LuaAPI.luaL_error(L, "cast to " + typeof(com.youzu.warh.protocol.Resource) + " exception:" + e);
				}

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for com.youzu.warh.protocol.Resource! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class comyouzuwarhprotocolTargetCoordinateTypeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(com.youzu.warh.protocol.TargetCoordinateType), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(com.youzu.warh.protocol.TargetCoordinateType), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(com.youzu.warh.protocol.TargetCoordinateType), L, null, 47, 0, 0);

            Utils.RegisterEnumType(L, typeof(com.youzu.warh.protocol.TargetCoordinateType));

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(com.youzu.warh.protocol.TargetCoordinateType), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushcomyouzuwarhprotocolTargetCoordinateType(L, (com.youzu.warh.protocol.TargetCoordinateType)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

                try
				{
                    translator.TranslateToEnumToTop(L, typeof(com.youzu.warh.protocol.TargetCoordinateType), 1);
				}
				catch (System.Exception e)
				{
					return LuaAPI.luaL_error(L, "cast to " + typeof(com.youzu.warh.protocol.TargetCoordinateType) + " exception:" + e);
				}

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for com.youzu.warh.protocol.TargetCoordinateType! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class YoozooGameplayLibertyPlayerControllerControlModeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(Yoozoo.Gameplay.Liberty.PlayerController.ControlMode), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(Yoozoo.Gameplay.Liberty.PlayerController.ControlMode), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(Yoozoo.Gameplay.Liberty.PlayerController.ControlMode), L, null, 5, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Input", Yoozoo.Gameplay.Liberty.PlayerController.ControlMode.Input);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AutoNav", Yoozoo.Gameplay.Liberty.PlayerController.ControlMode.AutoNav);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Hanging", Yoozoo.Gameplay.Liberty.PlayerController.ControlMode.Hanging);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DriveCar", Yoozoo.Gameplay.Liberty.PlayerController.ControlMode.DriveCar);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(Yoozoo.Gameplay.Liberty.PlayerController.ControlMode), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushYoozooGameplayLibertyPlayerControllerControlMode(L, (Yoozoo.Gameplay.Liberty.PlayerController.ControlMode)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Input"))
                {
                    translator.PushYoozooGameplayLibertyPlayerControllerControlMode(L, Yoozoo.Gameplay.Liberty.PlayerController.ControlMode.Input);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "AutoNav"))
                {
                    translator.PushYoozooGameplayLibertyPlayerControllerControlMode(L, Yoozoo.Gameplay.Liberty.PlayerController.ControlMode.AutoNav);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Hanging"))
                {
                    translator.PushYoozooGameplayLibertyPlayerControllerControlMode(L, Yoozoo.Gameplay.Liberty.PlayerController.ControlMode.Hanging);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "DriveCar"))
                {
                    translator.PushYoozooGameplayLibertyPlayerControllerControlMode(L, Yoozoo.Gameplay.Liberty.PlayerController.ControlMode.DriveCar);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for Yoozoo.Gameplay.Liberty.PlayerController.ControlMode!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for Yoozoo.Gameplay.Liberty.PlayerController.ControlMode! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class YoozooGameplayLibertyPlayerControllerEnterExitCarStateWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(Yoozoo.Gameplay.Liberty.PlayerController.EnterExitCarState), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(Yoozoo.Gameplay.Liberty.PlayerController.EnterExitCarState), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(Yoozoo.Gameplay.Liberty.PlayerController.EnterExitCarState), L, null, 10, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "None", Yoozoo.Gameplay.Liberty.PlayerController.EnterExitCarState.None);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ReadyNav2Door", Yoozoo.Gameplay.Liberty.PlayerController.EnterExitCarState.ReadyNav2Door);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CarEntityFreeze", Yoozoo.Gameplay.Liberty.PlayerController.EnterExitCarState.CarEntityFreeze);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Navigating", Yoozoo.Gameplay.Liberty.PlayerController.EnterExitCarState.Navigating);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NavComplete", Yoozoo.Gameplay.Liberty.PlayerController.EnterExitCarState.NavComplete);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BeginEnterCar", Yoozoo.Gameplay.Liberty.PlayerController.EnterExitCarState.BeginEnterCar);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "EnterCarComplete", Yoozoo.Gameplay.Liberty.PlayerController.EnterExitCarState.EnterCarComplete);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BeginExitCar", Yoozoo.Gameplay.Liberty.PlayerController.EnterExitCarState.BeginExitCar);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ExitCarComplete", Yoozoo.Gameplay.Liberty.PlayerController.EnterExitCarState.ExitCarComplete);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(Yoozoo.Gameplay.Liberty.PlayerController.EnterExitCarState), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushYoozooGameplayLibertyPlayerControllerEnterExitCarState(L, (Yoozoo.Gameplay.Liberty.PlayerController.EnterExitCarState)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "None"))
                {
                    translator.PushYoozooGameplayLibertyPlayerControllerEnterExitCarState(L, Yoozoo.Gameplay.Liberty.PlayerController.EnterExitCarState.None);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "ReadyNav2Door"))
                {
                    translator.PushYoozooGameplayLibertyPlayerControllerEnterExitCarState(L, Yoozoo.Gameplay.Liberty.PlayerController.EnterExitCarState.ReadyNav2Door);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "CarEntityFreeze"))
                {
                    translator.PushYoozooGameplayLibertyPlayerControllerEnterExitCarState(L, Yoozoo.Gameplay.Liberty.PlayerController.EnterExitCarState.CarEntityFreeze);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Navigating"))
                {
                    translator.PushYoozooGameplayLibertyPlayerControllerEnterExitCarState(L, Yoozoo.Gameplay.Liberty.PlayerController.EnterExitCarState.Navigating);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "NavComplete"))
                {
                    translator.PushYoozooGameplayLibertyPlayerControllerEnterExitCarState(L, Yoozoo.Gameplay.Liberty.PlayerController.EnterExitCarState.NavComplete);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "BeginEnterCar"))
                {
                    translator.PushYoozooGameplayLibertyPlayerControllerEnterExitCarState(L, Yoozoo.Gameplay.Liberty.PlayerController.EnterExitCarState.BeginEnterCar);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "EnterCarComplete"))
                {
                    translator.PushYoozooGameplayLibertyPlayerControllerEnterExitCarState(L, Yoozoo.Gameplay.Liberty.PlayerController.EnterExitCarState.EnterCarComplete);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "BeginExitCar"))
                {
                    translator.PushYoozooGameplayLibertyPlayerControllerEnterExitCarState(L, Yoozoo.Gameplay.Liberty.PlayerController.EnterExitCarState.BeginExitCar);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "ExitCarComplete"))
                {
                    translator.PushYoozooGameplayLibertyPlayerControllerEnterExitCarState(L, Yoozoo.Gameplay.Liberty.PlayerController.EnterExitCarState.ExitCarComplete);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for Yoozoo.Gameplay.Liberty.PlayerController.EnterExitCarState!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for Yoozoo.Gameplay.Liberty.PlayerController.EnterExitCarState! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class SystemNetNetworkInformationNetworkInterfaceTypeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(System.Net.NetworkInformation.NetworkInterfaceType), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(System.Net.NetworkInformation.NetworkInterfaceType), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(System.Net.NetworkInformation.NetworkInterfaceType), L, null, 29, 0, 0);

            Utils.RegisterEnumType(L, typeof(System.Net.NetworkInformation.NetworkInterfaceType));

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(System.Net.NetworkInformation.NetworkInterfaceType), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushSystemNetNetworkInformationNetworkInterfaceType(L, (System.Net.NetworkInformation.NetworkInterfaceType)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

                try
				{
                    translator.TranslateToEnumToTop(L, typeof(System.Net.NetworkInformation.NetworkInterfaceType), 1);
				}
				catch (System.Exception e)
				{
					return LuaAPI.luaL_error(L, "cast to " + typeof(System.Net.NetworkInformation.NetworkInterfaceType) + " exception:" + e);
				}

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for System.Net.NetworkInformation.NetworkInterfaceType! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class SystemNetSocketsAddressFamilyWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(System.Net.Sockets.AddressFamily), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(System.Net.Sockets.AddressFamily), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(System.Net.Sockets.AddressFamily), L, null, 32, 0, 0);

            Utils.RegisterEnumType(L, typeof(System.Net.Sockets.AddressFamily));

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(System.Net.Sockets.AddressFamily), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushSystemNetSocketsAddressFamily(L, (System.Net.Sockets.AddressFamily)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

                try
				{
                    translator.TranslateToEnumToTop(L, typeof(System.Net.Sockets.AddressFamily), 1);
				}
				catch (System.Exception e)
				{
					return LuaAPI.luaL_error(L, "cast to " + typeof(System.Net.Sockets.AddressFamily) + " exception:" + e);
				}

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for System.Net.Sockets.AddressFamily! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class YoozooGameplayRTSProtoMarchTypeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(Yoozoo.Gameplay.RTS.Proto.MarchType), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(Yoozoo.Gameplay.RTS.Proto.MarchType), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(Yoozoo.Gameplay.RTS.Proto.MarchType), L, null, 19, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "INIT", Yoozoo.Gameplay.RTS.Proto.MarchType.INIT);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "HOME_0", Yoozoo.Gameplay.RTS.Proto.MarchType.HOME_0);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ATTACK_1", Yoozoo.Gameplay.RTS.Proto.MarchType.ATTACK_1);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "GARRISON_2", Yoozoo.Gameplay.RTS.Proto.MarchType.GARRISON_2);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "COLLECT_3", Yoozoo.Gameplay.RTS.Proto.MarchType.COLLECT_3);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RETURN_4", Yoozoo.Gameplay.RTS.Proto.MarchType.RETURN_4);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DIE_5", Yoozoo.Gameplay.RTS.Proto.MarchType.DIE_5);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DEFENCE_6", Yoozoo.Gameplay.RTS.Proto.MarchType.DEFENCE_6);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SCOUT_7", Yoozoo.Gameplay.RTS.Proto.MarchType.SCOUT_7);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AID_8", Yoozoo.Gameplay.RTS.Proto.MarchType.AID_8);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RESCUE_9", Yoozoo.Gameplay.RTS.Proto.MarchType.RESCUE_9);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ASSEMBLY_JOIN_11", Yoozoo.Gameplay.RTS.Proto.MarchType.ASSEMBLY_JOIN_11);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ASSEMBLY_OUT_12", Yoozoo.Gameplay.RTS.Proto.MarchType.ASSEMBLY_OUT_12);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "WONDER_13", Yoozoo.Gameplay.RTS.Proto.MarchType.WONDER_13);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "EXPLORE_14", Yoozoo.Gameplay.RTS.Proto.MarchType.EXPLORE_14);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CONVOY_15", Yoozoo.Gameplay.RTS.Proto.MarchType.CONVOY_15);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "TRADE_TRUCK_16", Yoozoo.Gameplay.RTS.Proto.MarchType.TRADE_TRUCK_16);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "TRAIN_17", Yoozoo.Gameplay.RTS.Proto.MarchType.TRAIN_17);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(Yoozoo.Gameplay.RTS.Proto.MarchType), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushYoozooGameplayRTSProtoMarchType(L, (Yoozoo.Gameplay.RTS.Proto.MarchType)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "INIT"))
                {
                    translator.PushYoozooGameplayRTSProtoMarchType(L, Yoozoo.Gameplay.RTS.Proto.MarchType.INIT);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "HOME_0"))
                {
                    translator.PushYoozooGameplayRTSProtoMarchType(L, Yoozoo.Gameplay.RTS.Proto.MarchType.HOME_0);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "ATTACK_1"))
                {
                    translator.PushYoozooGameplayRTSProtoMarchType(L, Yoozoo.Gameplay.RTS.Proto.MarchType.ATTACK_1);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "GARRISON_2"))
                {
                    translator.PushYoozooGameplayRTSProtoMarchType(L, Yoozoo.Gameplay.RTS.Proto.MarchType.GARRISON_2);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "COLLECT_3"))
                {
                    translator.PushYoozooGameplayRTSProtoMarchType(L, Yoozoo.Gameplay.RTS.Proto.MarchType.COLLECT_3);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "RETURN_4"))
                {
                    translator.PushYoozooGameplayRTSProtoMarchType(L, Yoozoo.Gameplay.RTS.Proto.MarchType.RETURN_4);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "DIE_5"))
                {
                    translator.PushYoozooGameplayRTSProtoMarchType(L, Yoozoo.Gameplay.RTS.Proto.MarchType.DIE_5);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "DEFENCE_6"))
                {
                    translator.PushYoozooGameplayRTSProtoMarchType(L, Yoozoo.Gameplay.RTS.Proto.MarchType.DEFENCE_6);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "SCOUT_7"))
                {
                    translator.PushYoozooGameplayRTSProtoMarchType(L, Yoozoo.Gameplay.RTS.Proto.MarchType.SCOUT_7);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "AID_8"))
                {
                    translator.PushYoozooGameplayRTSProtoMarchType(L, Yoozoo.Gameplay.RTS.Proto.MarchType.AID_8);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "RESCUE_9"))
                {
                    translator.PushYoozooGameplayRTSProtoMarchType(L, Yoozoo.Gameplay.RTS.Proto.MarchType.RESCUE_9);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "ASSEMBLY_JOIN_11"))
                {
                    translator.PushYoozooGameplayRTSProtoMarchType(L, Yoozoo.Gameplay.RTS.Proto.MarchType.ASSEMBLY_JOIN_11);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "ASSEMBLY_OUT_12"))
                {
                    translator.PushYoozooGameplayRTSProtoMarchType(L, Yoozoo.Gameplay.RTS.Proto.MarchType.ASSEMBLY_OUT_12);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "WONDER_13"))
                {
                    translator.PushYoozooGameplayRTSProtoMarchType(L, Yoozoo.Gameplay.RTS.Proto.MarchType.WONDER_13);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "EXPLORE_14"))
                {
                    translator.PushYoozooGameplayRTSProtoMarchType(L, Yoozoo.Gameplay.RTS.Proto.MarchType.EXPLORE_14);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "CONVOY_15"))
                {
                    translator.PushYoozooGameplayRTSProtoMarchType(L, Yoozoo.Gameplay.RTS.Proto.MarchType.CONVOY_15);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "TRADE_TRUCK_16"))
                {
                    translator.PushYoozooGameplayRTSProtoMarchType(L, Yoozoo.Gameplay.RTS.Proto.MarchType.TRADE_TRUCK_16);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "TRAIN_17"))
                {
                    translator.PushYoozooGameplayRTSProtoMarchType(L, Yoozoo.Gameplay.RTS.Proto.MarchType.TRAIN_17);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for Yoozoo.Gameplay.RTS.Proto.MarchType!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for Yoozoo.Gameplay.RTS.Proto.MarchType! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class YoozooGameplayRTSProtoNormalAttackTypeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(Yoozoo.Gameplay.RTS.Proto.NormalAttackType), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(Yoozoo.Gameplay.RTS.Proto.NormalAttackType), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(Yoozoo.Gameplay.RTS.Proto.NormalAttackType), L, null, 4, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NORMAL_ATTACK_1", Yoozoo.Gameplay.RTS.Proto.NormalAttackType.NORMAL_ATTACK_1);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "COUNTER_ATTACK_2", Yoozoo.Gameplay.RTS.Proto.NormalAttackType.COUNTER_ATTACK_2);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SIEGE_ATTACK_3", Yoozoo.Gameplay.RTS.Proto.NormalAttackType.SIEGE_ATTACK_3);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(Yoozoo.Gameplay.RTS.Proto.NormalAttackType), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushYoozooGameplayRTSProtoNormalAttackType(L, (Yoozoo.Gameplay.RTS.Proto.NormalAttackType)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "NORMAL_ATTACK_1"))
                {
                    translator.PushYoozooGameplayRTSProtoNormalAttackType(L, Yoozoo.Gameplay.RTS.Proto.NormalAttackType.NORMAL_ATTACK_1);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "COUNTER_ATTACK_2"))
                {
                    translator.PushYoozooGameplayRTSProtoNormalAttackType(L, Yoozoo.Gameplay.RTS.Proto.NormalAttackType.COUNTER_ATTACK_2);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "SIEGE_ATTACK_3"))
                {
                    translator.PushYoozooGameplayRTSProtoNormalAttackType(L, Yoozoo.Gameplay.RTS.Proto.NormalAttackType.SIEGE_ATTACK_3);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for Yoozoo.Gameplay.RTS.Proto.NormalAttackType!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for Yoozoo.Gameplay.RTS.Proto.NormalAttackType! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
}
